prab-cli 1.2.1 → 1.2.5

package/dist/index.js

@@ -53,6 +53,8 @@ const file_tools_1 = require("./lib/tools/file-tools");
 const shell_tools_1 = require("./lib/tools/shell-tools");
 const git_tools_1 = require("./lib/tools/git-tools");
 const todo_tool_1 = require("./lib/tools/todo-tool");
+// Import crypto signal system
+const crypto_1 = require("./lib/crypto");
 // Import model system
 const groq_provider_1 = require("./lib/models/groq-provider");
 const registry_1 = require("./lib/models/registry");
@@ -98,6 +100,78 @@ program
     (0, config_1.clearApiKey)();
     ui_1.log.success("API Key cleared!");
 });
+// SMC (Smart Money Concepts) analysis command
+program
+    .command("smc <crypto>")
+    .description("Smart Money Concepts analysis (Order Blocks, FVG, Liquidity)")
+    .action(async (crypto) => {
+    await (0, crypto_1.runSMCAnalysis)(crypto);
+});
+// Comprehensive analysis command
+program
+    .command("analyze <crypto>")
+    .description("Deep market analysis with multi-timeframe & all indicators")
+    .action(async (crypto) => {
+    await (0, crypto_1.comprehensiveAnalysis)(crypto);
+});
+// Quick trading signal command
+program
+    .command("signal <crypto>")
+    .description("Quick trading signal for a cryptocurrency (e.g., prab-cli signal btc)")
+    .option("-i, --interval <interval>", "Time interval (1m, 5m, 15m, 1h, 4h, 1d, 1w)", "1h")
+    .action(async (crypto, options) => {
+    const validIntervals = ["1m", "5m", "15m", "1h", "4h", "1d", "1w"];
+    const interval = validIntervals.includes(options.interval)
+        ? options.interval
+        : "1h";
+    await (0, crypto_1.fullSignal)(crypto, interval);
+});
+// List supported cryptocurrencies
+program
+    .command("crypto-list")
+    .description("List supported cryptocurrency symbols")
+    .action(() => {
+    console.log("\nSupported Cryptocurrencies:\n");
+    const symbols = (0, crypto_1.getSupportedSymbols)();
+    const columns = 4;
+    for (let i = 0; i < symbols.length; i += columns) {
+        const row = symbols
+            .slice(i, i + columns)
+            .map((s) => s.padEnd(12))
+            .join("");
+        console.log("  " + row);
+    }
+    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);
+});
 // Model management commands
 program
     .command("model")
@@ -239,6 +313,111 @@ program.action(async () => {
             }
             // Execute the selected command
             switch (action) {
+                case "smc": {
+                    // Prompt for crypto symbol
+                    const { cryptoSymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "cryptoSymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    await (0, crypto_1.runSMCAnalysis)(cryptoSymbol);
+                    break;
+                }
+                case "analyze": {
+                    // Prompt for crypto symbol
+                    const { cryptoSymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "cryptoSymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    await (0, crypto_1.comprehensiveAnalysis)(cryptoSymbol);
+                    break;
+                }
+                case "signal": {
+                    // Prompt for crypto symbol
+                    const { cryptoSymbol } = await inquirer_1.default.prompt([
+                        {
+                            type: "input",
+                            name: "cryptoSymbol",
+                            message: "Enter cryptocurrency symbol (e.g., btc, eth, sol):",
+                            default: "btc",
+                        },
+                    ]);
+                    // Prompt for interval
+                    const intervalChoice = await (0, select_1.default)({
+                        message: "Select time interval:",
+                        choices: [
+                            { name: "1 Hour (recommended)", value: "1h" },
+                            { name: "15 Minutes", value: "15m" },
+                            { name: "4 Hours", value: "4h" },
+                            { name: "1 Day", value: "1d" },
+                        ],
+                    });
+                    await (0, crypto_1.fullSignal)(cryptoSymbol, intervalChoice);
+                    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 "model": {
                     // Fetch models from Groq API if not cached
                     if (cachedModels.length === 0) {
@@ -279,7 +458,7 @@ program.action(async () => {
                             ui_1.log.info(`Already using ${selectedModel}`);
                         }
                     }
-                    catch (e) {
+                    catch {
                         // User cancelled with Ctrl+C
                     }
                     break;
@@ -526,7 +705,7 @@ program.action(async () => {
                     ui_1.log.info("Keeping current model. You can try again or switch models with /model");
                 }
             }
-            catch (e) {
+            catch {
                 // User cancelled with Ctrl+C
                 ui_1.log.info("Model switch cancelled.");
             }

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/analyzer.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Technical Analysis Module
+ * Calculates EMA and generates trading signals
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateEMA = calculateEMA;
+exports.calculateAllEMAs = calculateAllEMAs;
+exports.calculateIndicators = calculateIndicators;
+exports.generateSignal = generateSignal;
+exports.formatSignalSummary = formatSignalSummary;
+/**
+ * Calculate Exponential Moving Average
+ */
+function calculateEMA(prices, period) {
+    if (prices.length < period) {
+        return [];
+    }
+    const ema = [];
+    const multiplier = 2 / (period + 1);
+    // First EMA value is SMA of first 'period' prices
+    let sum = 0;
+    for (let i = 0; i < period; i++) {
+        sum += prices[i];
+    }
+    ema.push(sum / period);
+    // Calculate EMA for remaining prices
+    for (let i = period; i < prices.length; i++) {
+        const currentEMA = (prices[i] - ema[ema.length - 1]) * multiplier + ema[ema.length - 1];
+        ema.push(currentEMA);
+    }
+    return ema;
+}
+/**
+ * Calculate all EMA values
+ */
+function calculateAllEMAs(candles) {
+    const closePrices = candles.map((c) => c.close);
+    return {
+        ema9: calculateEMA(closePrices, 9),
+        ema21: calculateEMA(closePrices, 21),
+        ema50: calculateEMA(closePrices, 50),
+        ema200: calculateEMA(closePrices, 200),
+    };
+}
+/**
+ * Detect EMA crossover patterns
+ */
+function detectCrossover(shortEMA, longEMA, lookback = 3) {
+    if (shortEMA.length < lookback + 1 || longEMA.length < lookback + 1) {
+        return "none";
+    }
+    const currentShort = shortEMA[shortEMA.length - 1];
+    const currentLong = longEMA[longEMA.length - 1];
+    const prevShort = shortEMA[shortEMA.length - lookback];
+    const prevLong = longEMA[longEMA.length - lookback];
+    // Golden cross: short EMA crosses above long EMA
+    if (prevShort <= prevLong && currentShort > currentLong) {
+        return "golden";
+    }
+    // Death cross: short EMA crosses below long EMA
+    if (prevShort >= prevLong && currentShort < currentLong) {
+        return "death";
+    }
+    return "none";
+}
+/**
+ * Determine price position relative to EMAs
+ */
+function getPriceVsEMA(currentPrice, ema9, ema21, ema50) {
+    const aboveCount = [ema9, ema21, ema50].filter((ema) => currentPrice > ema).length;
+    if (aboveCount === 3)
+        return "above_all";
+    if (aboveCount === 0)
+        return "below_all";
+    return "mixed";
+}
+/**
+ * Calculate trend strength based on EMA alignment
+ */
+function calculateTrendStrength(currentPrice, ema9, ema21, ema50, ema200) {
+    let strength = 0;
+    // Check EMA alignment (bullish: 9 > 21 > 50 > 200)
+    if (ema9 > ema21)
+        strength += 20;
+    if (ema21 > ema50)
+        strength += 20;
+    if (ema200 !== undefined && ema50 > ema200)
+        strength += 20;
+    // Check price vs EMAs
+    if (currentPrice > ema9)
+        strength += 10;
+    if (currentPrice > ema21)
+        strength += 10;
+    if (currentPrice > ema50)
+        strength += 10;
+    if (ema200 !== undefined && currentPrice > ema200)
+        strength += 10;
+    return Math.min(strength, 100);
+}
+/**
+ * Calculate technical indicators
+ */
+function calculateIndicators(data) {
+    const ema = calculateAllEMAs(data.candles);
+    const currentEMA9 = ema.ema9[ema.ema9.length - 1] || 0;
+    const currentEMA21 = ema.ema21[ema.ema21.length - 1] || 0;
+    const currentEMA50 = ema.ema50[ema.ema50.length - 1] || 0;
+    const currentEMA200 = ema.ema200.length > 0 ? ema.ema200[ema.ema200.length - 1] : undefined;
+    // Detect crossover between EMA9 and EMA21
+    const emaCrossover = detectCrossover(ema.ema9, ema.ema21);
+    // Price vs EMA position
+    const priceVsEMA = getPriceVsEMA(data.currentPrice, currentEMA9, currentEMA21, currentEMA50);
+    // Determine trend
+    let trend;
+    if (currentEMA9 > currentEMA21 && currentEMA21 > currentEMA50) {
+        trend = "bullish";
+    }
+    else if (currentEMA9 < currentEMA21 && currentEMA21 < currentEMA50) {
+        trend = "bearish";
+    }
+    else {
+        trend = "neutral";
+    }
+    // Calculate trend strength
+    const trendStrength = calculateTrendStrength(data.currentPrice, currentEMA9, currentEMA21, currentEMA50, currentEMA200);
+    return {
+        ema,
+        currentEMA9,
+        currentEMA21,
+        currentEMA50,
+        currentEMA200: currentEMA200 || 0,
+        emaCrossover,
+        priceVsEMA,
+        trend,
+        trendStrength,
+    };
+}
+/**
+ * Generate trading signal based on EMA analysis
+ */
+function generateSignal(data) {
+    const indicators = calculateIndicators(data);
+    const reasoning = [];
+    let signal = "HOLD";
+    let confidence = 50;
+    let stopLoss = 3;
+    let takeProfit = 6;
+    // EMA Crossover signals
+    if (indicators.emaCrossover === "golden") {
+        signal = "BUY";
+        confidence += 25;
+        reasoning.push("Golden cross detected (EMA9 crossed above EMA21)");
+    }
+    else if (indicators.emaCrossover === "death") {
+        signal = "SELL";
+        confidence += 25;
+        reasoning.push("Death cross detected (EMA9 crossed below EMA21)");
+    }
+    // Price position relative to EMAs
+    if (indicators.priceVsEMA === "above_all") {
+        if (signal !== "SELL") {
+            signal = signal === "HOLD" ? "BUY" : signal;
+            confidence += 15;
+        }
+        reasoning.push("Price is above all major EMAs (9, 21, 50)");
+    }
+    else if (indicators.priceVsEMA === "below_all") {
+        if (signal !== "BUY") {
+            signal = signal === "HOLD" ? "SELL" : signal;
+            confidence += 15;
+        }
+        reasoning.push("Price is below all major EMAs (9, 21, 50)");
+    }
+    else {
+        reasoning.push("Price is mixed relative to EMAs - consolidation phase");
+    }
+    // Trend analysis
+    if (indicators.trend === "bullish") {
+        if (signal !== "SELL") {
+            confidence += 10;
+        }
+        reasoning.push("EMAs are aligned bullishly (EMA9 > EMA21 > EMA50)");
+    }
+    else if (indicators.trend === "bearish") {
+        if (signal !== "BUY") {
+            confidence += 10;
+        }
+        reasoning.push("EMAs are aligned bearishly (EMA9 < EMA21 < EMA50)");
+    }
+    else {
+        reasoning.push("EMAs show no clear trend alignment");
+    }
+    // EMA200 analysis (if available)
+    if (indicators.currentEMA200 > 0) {
+        if (data.currentPrice > indicators.currentEMA200) {
+            if (signal === "BUY")
+                confidence += 10;
+            reasoning.push("Price is above EMA200 (long-term bullish)");
+        }
+        else {
+            if (signal === "SELL")
+                confidence += 10;
+            reasoning.push("Price is below EMA200 (long-term bearish)");
+        }
+    }
+    // 24h price change consideration
+    if (Math.abs(data.priceChangePercent24h) > 5) {
+        if (data.priceChangePercent24h > 5 && signal === "BUY") {
+            reasoning.push(`Strong momentum: +${data.priceChangePercent24h.toFixed(2)}% in 24h`);
+            confidence += 5;
+        }
+        else if (data.priceChangePercent24h < -5 && signal === "SELL") {
+            reasoning.push(`Strong downward momentum: ${data.priceChangePercent24h.toFixed(2)}% in 24h`);
+            confidence += 5;
+        }
+        else if (Math.abs(data.priceChangePercent24h) > 10) {
+            reasoning.push(`Caution: High volatility (${data.priceChangePercent24h.toFixed(2)}% in 24h)`);
+            confidence -= 5;
+        }
+    }
+    // Adjust stop-loss and take-profit based on signal and confidence
+    if (signal === "BUY") {
+        // Set stop-loss below recent support (EMA21)
+        const distanceToEMA21 = ((data.currentPrice - indicators.currentEMA21) / data.currentPrice) * 100;
+        stopLoss = Math.max(2, Math.min(distanceToEMA21 + 1, 5));
+        takeProfit = stopLoss * 2; // 2:1 risk-reward ratio
+    }
+    else if (signal === "SELL") {
+        // For sell signals, stop-loss above resistance
+        const distanceToEMA21 = ((indicators.currentEMA21 - data.currentPrice) / data.currentPrice) * 100;
+        stopLoss = Math.max(2, Math.min(Math.abs(distanceToEMA21) + 1, 5));
+        takeProfit = stopLoss * 2;
+    }
+    // Cap confidence at 95%
+    confidence = Math.min(confidence, 95);
+    confidence = Math.max(confidence, 10);
+    // If no clear signals, suggest HOLD
+    if (reasoning.length <= 2 && indicators.emaCrossover === "none") {
+        signal = "HOLD";
+        reasoning.push("No clear trading signal - recommend waiting for better setup");
+    }
+    return {
+        signal,
+        confidence,
+        stopLoss: Math.round(stopLoss * 10) / 10,
+        takeProfit: Math.round(takeProfit * 10) / 10,
+        indicators,
+        reasoning,
+    };
+}
+/**
+ * Format signal for display
+ */
+function formatSignalSummary(signal, symbol, price) {
+    const signalEmoji = signal.signal === "BUY" ? "\u{1F7E2}" : signal.signal === "SELL" ? "\u{1F534}" : "\u{1F7E1}";
+    const trendEmoji = signal.indicators.trend === "bullish"
+        ? "\u{2197}\u{FE0F}"
+        : signal.indicators.trend === "bearish"
+            ? "\u{2198}\u{FE0F}"
+            : "\u{27A1}\u{FE0F}";
+    return `
+${signalEmoji} Signal: ${signal.signal}
+Confidence: ${signal.confidence}%
+Stop-Loss: ${signal.stopLoss}%
+Take-Profit: ${signal.takeProfit}%
+
+Current Price: $${price.toLocaleString()}
+Trend: ${signal.indicators.trend} ${trendEmoji}
+EMA9: $${signal.indicators.currentEMA9.toFixed(2)}
+EMA21: $${signal.indicators.currentEMA21.toFixed(2)}
+EMA50: $${signal.indicators.currentEMA50.toFixed(2)}
+${signal.indicators.currentEMA200 > 0 ? `EMA200: $${signal.indicators.currentEMA200.toFixed(2)}` : ""}
+`;
+}