prab-cli 1.2.4 → 1.2.6

package/dist/index.js

@@ -144,6 +144,76 @@ program
     console.log("\nYou can also use any Binance trading pair (e.g., BTCUSDT, ETHBTC)");
     console.log("");
 });
+// Whale activity tracker
+program
+    .command("whale")
+    .description("Track whale activity (large BTC/ETH transactions)")
+    .option("-c, --coins <coins>", "Coins to track (comma-separated)", "BTC,ETH")
+    .action(async (options) => {
+    const coins = options.coins.split(",").map((c) => c.trim().toUpperCase());
+    await (0, crypto_1.runWhaleTracker)(coins);
+});
+// Market scanner for opportunities
+program
+    .command("scan")
+    .description("Scan market for best trading opportunities")
+    .option("-l, --limit <number>", "Number of cryptos to scan (max 100)", "50")
+    .option("-m, --min-score <number>", "Minimum score to display", "50")
+    .action(async (options) => {
+    const limit = Math.min(parseInt(options.limit) || 50, 100);
+    const minScore = parseInt(options.minScore) || 50;
+    await (0, crypto_1.runMarketScanner)(limit, minScore);
+});
+// Crypto news fetcher
+program
+    .command("news")
+    .description("Get latest cryptocurrency news and updates")
+    .option("-c, --coin <coin>", "Filter news by specific coin (e.g., btc, eth)")
+    .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")
@@ -308,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": {
@@ -331,7 +406,148 @@ 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": {
+                    // Prompt for coins to track
+                    const { coins } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "coins",
+                            message: "Enter coins to track (comma-separated):",
+                            default: "BTC,ETH",
+                        },
+                    ]);
+                    const coinList = coins.split(",").map((c) => c.trim().toUpperCase());
+                    await (0, crypto_1.runWhaleTracker)(coinList);
+                    break;
+                }
+                case "scan": {
+                    // Prompt for scan options
+                    const scanLimit = await (0, select_1.default)({
+                        message: "How many cryptocurrencies to scan?",
+                        choices: [
+                            { name: "Top 20 (Quick)", value: 20 },
+                            { name: "Top 50 (Recommended)", value: 50 },
+                            { name: "Top 100 (Comprehensive)", value: 100 },
+                        ],
+                    });
+                    await (0, crypto_1.runMarketScanner)(scanLimit, 50);
+                    break;
+                }
+                case "news": {
+                    // Prompt for optional coin filter
+                    const newsFilterChoice = await (0, select_1.default)({
+                        message: "Filter news by coin?",
+                        choices: [
+                            { name: "All Crypto News", value: "" },
+                            { name: "Bitcoin (BTC)", value: "BTC" },
+                            { name: "Ethereum (ETH)", value: "ETH" },
+                            { name: "Solana (SOL)", value: "SOL" },
+                            { name: "Other (specify)", value: "__other__" },
+                        ],
+                    });
+                    let coinFilter;
+                    if (newsFilterChoice === "__other__") {
+                        const { customCoin } = await inquirer_1.default.prompt([
+                            {
+                                type: "input",
+                                name: "customCoin",
+                                message: "Enter coin symbol (e.g., XRP, ADA, DOGE):",
+                            },
+                        ]);
+                        coinFilter = customCoin.trim().toUpperCase() || undefined;
+                    }
+                    else if (newsFilterChoice) {
+                        coinFilter = newsFilterChoice;
+                    }
+                    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": {

package/dist/lib/chat-handler.js

@@ -82,6 +82,10 @@ When you need to perform file operations, use the appropriate tools rather than
                 let fullResponse = "";
                 let toolCalls = [];
                 const formatter = new ui_1.StreamFormatter();
+                // Track tokens for this specific request
+                let requestPromptTokens = 0;
+                let requestCompletionTokens = 0;
+                let requestTotalTokens = 0;
                 process.stdout.write("\n");
                 try {
                     for await (const chunk of stream) {
@@ -98,11 +102,26 @@ When you need to perform file operations, use the appropriate tools rather than
                         if (chunk.tool_calls && chunk.tool_calls.length > 0) {
                             toolCalls = chunk.tool_calls;
                         }
-                        // Capture usage metadata from the chunk
+                        // Capture usage metadata from the chunk (LangChain uses different field names)
                         if (chunk.usage_metadata) {
-                            this.usage.promptTokens += chunk.usage_metadata.input_tokens || 0;
-                            this.usage.completionTokens += chunk.usage_metadata.output_tokens || 0;
-                            this.usage.totalTokens += chunk.usage_metadata.total_tokens || 0;
+                            requestPromptTokens =
+                                chunk.usage_metadata.input_tokens || chunk.usage_metadata.prompt_tokens || 0;
+                            requestCompletionTokens =
+                                chunk.usage_metadata.output_tokens || chunk.usage_metadata.completion_tokens || 0;
+                            requestTotalTokens =
+                                chunk.usage_metadata.total_tokens || requestPromptTokens + requestCompletionTokens;
+                            // Also update cumulative stats
+                            this.usage.promptTokens += requestPromptTokens;
+                            this.usage.completionTokens += requestCompletionTokens;
+                            this.usage.totalTokens += requestTotalTokens;
+                        }
+                        // Also check response_metadata (alternative LangChain format)
+                        if (chunk.response_metadata?.usage) {
+                            const usage = chunk.response_metadata.usage;
+                            requestPromptTokens = usage.prompt_tokens || usage.input_tokens || 0;
+                            requestCompletionTokens = usage.completion_tokens || usage.output_tokens || 0;
+                            requestTotalTokens =
+                                usage.total_tokens || requestPromptTokens + requestCompletionTokens;
                         }
                     }
                     // Increment request count
@@ -120,7 +139,22 @@ When you need to perform file operations, use the appropriate tools rather than
                     tracker_1.tracker.apiError(apiError.message, { stack: apiError.stack });
                     throw apiError;
                 }
-                process.stdout.write("\n\n");
+                process.stdout.write("\n");
+                // Estimate tokens if not provided by API (rough estimate: ~4 chars per token)
+                if (requestTotalTokens === 0 && fullResponse.length > 0) {
+                    // Estimate based on message content length
+                    const inputText = this.messages
+                        .map((m) => (typeof m.content === "string" ? m.content : ""))
+                        .join(" ");
+                    requestPromptTokens = Math.ceil(inputText.length / 4);
+                    requestCompletionTokens = Math.ceil(fullResponse.length / 4);
+                    requestTotalTokens = requestPromptTokens + requestCompletionTokens;
+                }
+                // Show token usage for this request
+                if (requestTotalTokens > 0) {
+                    (0, ui_1.showTokenUsageCompact)(requestPromptTokens, requestCompletionTokens, requestTotalTokens);
+                }
+                process.stdout.write("\n");
                 // Log AI response if there's content
                 if (fullResponse.length > 0) {
                     tracker_1.tracker.aiResponse(fullResponse);

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 };
+    }
+}