prab-cli 1.2.5 → 1.2.6

package/dist/index.js

@@ -172,6 +172,48 @@ program
     .action(async (options) => {
     await (0, crypto_1.runCryptoNews)(options.coin);
 });
+// Smart trading strategy
+program
+    .command("strategy <crypto>")
+    .description("Generate smart trading strategy with entry, exit, and leverage")
+    .option("-s, --style <style>", "Trading style: conservative, moderate, aggressive", "moderate")
+    .option("-l, --leverage <number>", "Maximum leverage allowed", "20")
+    .option("-d, --direction <direction>", "Trade direction: both, long, short", "both")
+    .action(async (crypto, options) => {
+    const style = ["conservative", "moderate", "aggressive"].includes(options.style)
+        ? options.style
+        : "moderate";
+    const maxLeverage = Math.min(parseInt(options.leverage) || 20, 100);
+    const direction = ["both", "long", "short"].includes(options.direction)
+        ? options.direction
+        : "both";
+    await (0, crypto_1.runStrategy)(crypto, { style, maxLeverage, direction });
+});
+// Order Block trading strategy
+program
+    .command("orderblock <crypto>")
+    .alias("ob")
+    .description("Order Block trading strategy with BUY/SELL signals based on OB zones")
+    .option("-i, --interval <interval>", "Time interval (15m, 1h, 4h, 1d)", "4h")
+    .action(async (crypto, options) => {
+    const validIntervals = ["15m", "1h", "4h", "1d"];
+    const interval = validIntervals.includes(options.interval)
+        ? options.interval
+        : "4h";
+    await (0, crypto_1.runOrderBlockStrategy)(crypto, interval);
+});
+// ICT (Inner Circle Trader) Strategy
+program
+    .command("ict <crypto>")
+    .description("ICT trading strategy - Killzones, OTE, Breakers, Silver Bullet, AMD")
+    .option("-i, --interval <interval>", "Time interval (15m, 1h, 4h)", "1h")
+    .action(async (crypto, options) => {
+    const validIntervals = ["15m", "1h", "4h"];
+    const interval = validIntervals.includes(options.interval)
+        ? options.interval
+        : "1h";
+    await (0, crypto_1.runICTStrategy)(crypto, interval);
+});
 // Model management commands
 program
     .command("model")
@@ -336,7 +378,12 @@ program.action(async () => {
                             default: "btc",
                         },
                     ]);
-                    await (0, crypto_1.comprehensiveAnalysis)(cryptoSymbol);
+                    try {
+                        await (0, crypto_1.comprehensiveAnalysis)(cryptoSymbol);
+                    }
+                    catch (err) {
+                        // Error already handled in comprehensiveAnalysis
+                    }
                     break;
                 }
                 case "signal": {
@@ -359,7 +406,12 @@ program.action(async () => {
                             { name: "1 Day", value: "1d" },
                         ],
                     });
-                    await (0, crypto_1.fullSignal)(cryptoSymbol, intervalChoice);
+                    try {
+                        await (0, crypto_1.fullSignal)(cryptoSymbol, intervalChoice);
+                    }
+                    catch (err) {
+                        // Error already handled in fullSignal
+                    }
                     break;
                 }
                 case "whale": {
@@ -418,6 +470,86 @@ program.action(async () => {
                     await (0, crypto_1.runCryptoNews)(coinFilter);
                     break;
                 }
+                case "strategy": {
+                    // Prompt for crypto symbol
+                    const { strategySymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "strategySymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    // Prompt for trading style
+                    const styleChoice = await (0, select_1.default)({
+                        message: "Select your trading style:",
+                        choices: [
+                            { name: "Conservative (5-10x leverage, wider stops)", value: "conservative" },
+                            { name: "Moderate (10-20x leverage, balanced) - Recommended", value: "moderate" },
+                            { name: "Aggressive (20-50x leverage, tighter stops)", value: "aggressive" },
+                        ],
+                    });
+                    // Prompt for direction
+                    const directionChoice = await (0, select_1.default)({
+                        message: "Trade direction:",
+                        choices: [
+                            { name: "Both Long & Short", value: "both" },
+                            { name: "Long Only", value: "long" },
+                            { name: "Short Only", value: "short" },
+                        ],
+                    });
+                    await (0, crypto_1.runStrategy)(strategySymbol, {
+                        style: styleChoice,
+                        direction: directionChoice,
+                        maxLeverage: styleChoice === "conservative" ? 10 : styleChoice === "moderate" ? 20 : 50,
+                    });
+                    break;
+                }
+                case "orderblock": {
+                    // Prompt for crypto symbol
+                    const { obSymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "obSymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    // Prompt for timeframe
+                    const obIntervalChoice = await (0, select_1.default)({
+                        message: "Select timeframe for Order Block analysis:",
+                        choices: [
+                            { name: "4 Hours (Recommended for swing trades)", value: "4h" },
+                            { name: "1 Hour (Intraday trades)", value: "1h" },
+                            { name: "15 Minutes (Scalping)", value: "15m" },
+                            { name: "1 Day (Position trades)", value: "1d" },
+                        ],
+                    });
+                    await (0, crypto_1.runOrderBlockStrategy)(obSymbol, obIntervalChoice);
+                    break;
+                }
+                case "ict": {
+                    // Prompt for crypto symbol
+                    const { ictSymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "ictSymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    // Prompt for timeframe
+                    const ictIntervalChoice = await (0, select_1.default)({
+                        message: "Select timeframe for ICT analysis:",
+                        choices: [
+                            { name: "1 Hour (Recommended for ICT)", value: "1h" },
+                            { name: "15 Minutes (Scalping with Silver Bullet)", value: "15m" },
+                            { name: "4 Hours (Higher timeframe bias)", value: "4h" },
+                        ],
+                    });
+                    await (0, crypto_1.runICTStrategy)(ictSymbol, ictIntervalChoice);
+                    break;
+                }
                 case "model": {
                     // Fetch models from Groq API if not cached
                     if (cachedModels.length === 0) {

package/dist/lib/crypto/data-fetcher.js

@@ -5,12 +5,15 @@
  * Fetches OHLCV data from Binance public API (no API key required)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAllSymbols = fetchAllSymbols;
+exports.findSimilarSymbols = findSimilarSymbols;
 exports.normalizeSymbol = normalizeSymbol;
 exports.fetchOHLCV = fetchOHLCV;
 exports.fetch24hTicker = fetch24hTicker;
 exports.fetchCryptoData = fetchCryptoData;
 exports.getSupportedSymbols = getSupportedSymbols;
 exports.isValidSymbol = isValidSymbol;
+exports.validateSymbol = validateSymbol;
 // Common crypto symbols mapping (user-friendly -> Binance format)
 const SYMBOL_MAP = {
     btc: "BTCUSDT",
@@ -57,6 +60,63 @@ const SYMBOL_MAP = {
     wif: "WIFUSDT",
 };
 const BINANCE_API_BASE = "https://api.binance.com/api/v3";
+// Cache for valid Binance symbols
+let cachedSymbols = null;
+let cacheTimestamp = 0;
+const CACHE_DURATION = 1000 * 60 * 60; // 1 hour cache
+/**
+ * Fetch all valid USDT trading pairs from Binance
+ */
+async function fetchAllSymbols() {
+    // Return cached symbols if still valid
+    if (cachedSymbols && Date.now() - cacheTimestamp < CACHE_DURATION) {
+        return cachedSymbols;
+    }
+    try {
+        const response = await fetch(`${BINANCE_API_BASE}/exchangeInfo`);
+        if (!response.ok) {
+            throw new Error("Failed to fetch exchange info");
+        }
+        const data = await response.json();
+        const symbols = new Set();
+        for (const symbol of data.symbols) {
+            // Only include USDT pairs that are trading
+            if (symbol.status === "TRADING" && symbol.quoteAsset === "USDT") {
+                symbols.add(symbol.symbol);
+                // Also add the base asset for easy lookup
+                symbols.add(symbol.baseAsset.toLowerCase());
+            }
+        }
+        cachedSymbols = symbols;
+        cacheTimestamp = Date.now();
+        return symbols;
+    }
+    catch (error) {
+        // Return empty set on error, will fall back to direct API check
+        return new Set();
+    }
+}
+/**
+ * Get similar symbols for suggestions
+ */
+async function findSimilarSymbols(input, limit = 5) {
+    const symbols = await fetchAllSymbols();
+    const inputUpper = input.toUpperCase();
+    const similar = [];
+    for (const symbol of symbols) {
+        // Only show USDT pairs, not base assets
+        if (!symbol.endsWith("USDT"))
+            continue;
+        const baseAsset = symbol.replace("USDT", "");
+        // Check if base asset starts with or contains the input
+        if (baseAsset.startsWith(inputUpper) || baseAsset.includes(inputUpper)) {
+            similar.push(baseAsset);
+            if (similar.length >= limit)
+                break;
+        }
+    }
+    return similar;
+}
 /**
  * Normalize symbol to Binance format
  */
@@ -156,6 +216,12 @@ function getSupportedSymbols() {
 async function isValidSymbol(symbol) {
     try {
         const normalizedSymbol = normalizeSymbol(symbol);
+        // First check cache
+        const symbols = await fetchAllSymbols();
+        if (symbols.has(normalizedSymbol)) {
+            return true;
+        }
+        // Fall back to direct API check
         const url = `${BINANCE_API_BASE}/ticker/price?symbol=${normalizedSymbol}`;
         const response = await fetch(url);
         return response.ok;
@@ -164,3 +230,23 @@ async function isValidSymbol(symbol) {
         return false;
     }
 }
+/**
+ * Validate symbol and get suggestions if invalid
+ */
+async function validateSymbol(symbol) {
+    const normalized = normalizeSymbol(symbol);
+    try {
+        const url = `${BINANCE_API_BASE}/ticker/price?symbol=${normalized}`;
+        const response = await fetch(url);
+        if (response.ok) {
+            return { valid: true, normalized, suggestions: [] };
+        }
+        // If invalid, find similar symbols
+        const suggestions = await findSimilarSymbols(symbol, 5);
+        return { valid: false, normalized, suggestions };
+    }
+    catch {
+        const suggestions = await findSimilarSymbols(symbol, 5);
+        return { valid: false, normalized, suggestions };
+    }
+}