@vizzor/cli 0.9.0 → 0.10.0

package/dist/index.js

@@ -139,6 +139,30 @@ function loadConfig() {
     }
     raw["ai"]["provider"] = process.env["VIZZOR_AI_PROVIDER"];
   }
+  if (process.env["DATABASE_TYPE"] || process.env["DATABASE_URL"]) {
+    if (!raw["database"] || typeof raw["database"] !== "object") {
+      raw["database"] = {};
+    }
+    const db2 = raw["database"];
+    if (process.env["DATABASE_TYPE"]) db2["type"] = process.env["DATABASE_TYPE"];
+    if (process.env["DATABASE_URL"]) db2["url"] = process.env["DATABASE_URL"];
+  }
+  if (process.env["ML_ENABLED"] || process.env["ML_SIDECAR_URL"]) {
+    if (!raw["ml"] || typeof raw["ml"] !== "object") {
+      raw["ml"] = {};
+    }
+    const ml = raw["ml"];
+    if (process.env["ML_ENABLED"]) ml["enabled"] = process.env["ML_ENABLED"] === "true";
+    if (process.env["ML_SIDECAR_URL"]) ml["sidecarUrl"] = process.env["ML_SIDECAR_URL"];
+  }
+  if (process.env["API_PORT"] || process.env["API_HOST"]) {
+    if (!raw["api"] || typeof raw["api"] !== "object") {
+      raw["api"] = {};
+    }
+    const api = raw["api"];
+    if (process.env["API_PORT"]) api["port"] = Number(process.env["API_PORT"]);
+    if (process.env["API_HOST"]) api["host"] = process.env["API_HOST"];
+  }
   const config2 = vizzorConfigSchema.parse(raw);
   cachedConfig = config2;
   return config2;
@@ -176,7 +200,10 @@ function saveConfigValue(key, value) {
     if (!raw[section] || typeof raw[section] !== "object") {
       raw[section] = {};
     }
-    const parsed = field === "maxTokens" ? Number(value) : value;
+    let parsed = value;
+    if (field === "maxTokens" || field === "port") parsed = Number(value);
+    else if (value === "true") parsed = true;
+    else if (value === "false") parsed = false;
     raw[section][field] = parsed;
   } else {
     raw[key] = value;
@@ -207,7 +234,18 @@ var init_loader = __esm({
       "ai.provider": { env: "VIZZOR_AI_PROVIDER", nested: "ai" },
       "ai.model": { env: "VIZZOR_AI_MODEL", nested: "ai" },
       "ai.maxTokens": { env: "VIZZOR_AI_MAX_TOKENS", nested: "ai" },
-      "ai.ollamaHost": { env: "OLLAMA_HOST", nested: "ai" }
+      "ai.ollamaHost": { env: "OLLAMA_HOST", nested: "ai" },
+      "database.type": { env: "DATABASE_TYPE", nested: "database" },
+      "database.url": { env: "DATABASE_URL", nested: "database" },
+      "ml.enabled": { env: "ML_ENABLED", nested: "ml" },
+      "ml.sidecarUrl": { env: "ML_SIDECAR_URL", nested: "ml" },
+      "ml.fallbackToRules": { env: "ML_FALLBACK_TO_RULES", nested: "ml" },
+      "api.port": { env: "API_PORT", nested: "api" },
+      "api.host": { env: "API_HOST", nested: "api" },
+      "api.enableAuth": { env: "API_ENABLE_AUTH", nested: "api" },
+      "api.corsOrigin": { env: "API_CORS_ORIGIN", nested: "api" },
+      "n8n.enabled": { env: "N8N_ENABLED", nested: "n8n" },
+      "n8n.webhookUrl": { env: "N8N_WEBHOOK_URL", nested: "n8n" }
     };
   }
 });
@@ -830,6 +868,329 @@ var init_registry = __esm({
   }
 });
 
+// src/utils/logger.ts
+import pino from "pino";
+function createLogger(name) {
+  const isDev = process.env["NODE_ENV"] !== "production";
+  if (isDev) {
+    return pino({
+      name,
+      level,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true
+        }
+      }
+    });
+  }
+  return pino({ name, level });
+}
+var level;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    level = process.env["VIZZOR_LOG_LEVEL"] ?? "info";
+  }
+});
+
+// src/ml/client.ts
+function initMLClient(url) {
+  mlClient = new MLClient(url);
+  return mlClient;
+}
+function getMLClient() {
+  return mlClient;
+}
+var log, MLClient, mlClient;
+var init_client = __esm({
+  "src/ml/client.ts"() {
+    "use strict";
+    init_logger();
+    log = createLogger("ml-client");
+    MLClient = class {
+      baseUrl;
+      healthy = false;
+      constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+      }
+      async predict(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML predict failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async batchPredict(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/batch`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ features }),
+            signal: AbortSignal.timeout(15e3)
+          });
+          if (!res.ok) return [];
+          const data = await res.json();
+          return data.predictions;
+        } catch (err) {
+          log.debug(`ML batch predict failed: ${err instanceof Error ? err.message : String(err)}`);
+          return [];
+        }
+      }
+      async detectAnomalies(flows) {
+        try {
+          const res = await fetch(`${this.baseUrl}/anomalies`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ flows }),
+            signal: AbortSignal.timeout(1e4)
+          });
+          if (!res.ok) return [];
+          const data = await res.json();
+          return data.anomalies;
+        } catch (err) {
+          log.debug(`ML anomaly detection failed: ${err instanceof Error ? err.message : String(err)}`);
+          return [];
+        }
+      }
+      async healthCheck() {
+        try {
+          const res = await fetch(`${this.baseUrl}/health`, {
+            signal: AbortSignal.timeout(3e3)
+          });
+          this.healthy = res.ok;
+          return this.healthy;
+        } catch {
+          this.healthy = false;
+          return false;
+        }
+      }
+      async predictRug(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/rug`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML rug predict failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async classifyWallet(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/wallet`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML wallet classify failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async analyzeSentiment(text) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/sentiment`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ text }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML sentiment failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async analyzeSentimentBatch(texts) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/sentiment/batch`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ texts }),
+            signal: AbortSignal.timeout(15e3)
+          });
+          if (!res.ok) return [];
+          const data = await res.json();
+          return data.results;
+        } catch (err) {
+          log.debug(`ML sentiment batch failed: ${err instanceof Error ? err.message : String(err)}`);
+          return [];
+        }
+      }
+      // -----------------------------------------------------------------------
+      // v0.11.0 — New ML endpoints
+      // -----------------------------------------------------------------------
+      async scoreTrend(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/trend`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML trend score failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async interpretTA(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/ta`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML TA interpret failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async evaluateStrategy(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/strategy`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML strategy eval failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async detectRegime(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/regime`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML regime detect failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async scoreProjectRisk(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/project-risk`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML project risk failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async optimizePortfolio(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/portfolio-opt`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML portfolio opt failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async classifyIntent(text) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/intent`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ text }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML intent classify failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async scoreBytecodeRisk(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/bytecode-risk`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML bytecode risk failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async predictPortfolioForward(features) {
+        try {
+          const res = await fetch(`${this.baseUrl}/predict/portfolio-forward`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(features),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch (err) {
+          log.debug(`ML portfolio forward failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+      async getModelHealth() {
+        try {
+          const res = await fetch(`${this.baseUrl}/health`, {
+            signal: AbortSignal.timeout(3e3)
+          });
+          if (!res.ok) return null;
+          return await res.json();
+        } catch {
+          return null;
+        }
+      }
+      isHealthy() {
+        return this.healthy;
+      }
+    };
+    mlClient = null;
+  }
+});
+
 // src/core/scanner/project-analyzer.ts
 async function analyzeProject(address, adapter) {
   const [token, code, holders] = await Promise.allSettled([
@@ -848,17 +1209,48 @@ async function analyzeProject(address, adapter) {
   );
   const totalSupply = tokenInfo?.totalSupply ?? 0n;
   const topHolderPercentage = topHolders.length > 0 && totalSupply > 0n ? Number((topHolders[0]?.balance ?? 0n) * 10000n / totalSupply) / 100 : 0;
+  const topHoldersMapped = topHolders.map((h) => ({
+    address: h.address,
+    percentage: totalSupply > 0n ? Number(h.balance * 10000n / totalSupply) / 100 : 0
+  }));
+  const top10Pct = topHoldersMapped.reduce((sum, h) => sum + h.percentage, 0);
+  let mlRisk;
+  const mlClient2 = getMLClient();
+  if (mlClient2) {
+    try {
+      const result = await mlClient2.scoreProjectRisk({
+        bytecode_size: contractCode.length,
+        is_verified: hasSourceCode ? 1 : 0,
+        holder_concentration: topHolderPercentage,
+        has_proxy: 0,
+        has_mint: 0,
+        has_pause: 0,
+        has_blacklist: 0,
+        liquidity_locked: 0,
+        buy_tax: 0,
+        sell_tax: 0,
+        contract_age_days: 0,
+        total_transfers: 0,
+        owner_balance_pct: topHolderPercentage,
+        is_open_source: hasSourceCode ? 1 : 0,
+        top10_holder_pct: top10Pct,
+        has_token_info: tokenInfo ? 1 : 0
+      });
+      if (result) {
+        mlRisk = result;
+      }
+    } catch {
+    }
+  }
   return {
     token: tokenInfo,
     contractVerified: hasSourceCode,
     hasSourceCode,
     holderConcentration: topHolderPercentage,
-    topHolders: topHolders.map((h) => ({
-      address: h.address,
-      percentage: totalSupply > 0n ? Number(h.balance * 10000n / totalSupply) / 100 : 0
-    })),
+    topHolders: topHoldersMapped,
     riskIndicators,
-    riskScore: Math.min(100, riskScore)
+    riskScore: Math.min(100, riskScore),
+    mlRisk
   };
 }
 function evaluateRiskIndicators(token, hasSource, topHolders) {
@@ -893,16 +1285,30 @@ function evaluateRiskIndicators(token, hasSource, topHolders) {
 var init_project_analyzer = __esm({
   "src/core/scanner/project-analyzer.ts"() {
     "use strict";
+    init_client();
   }
 });
 
 // src/core/scanner/risk-scorer.ts
 function assessRisk(analysis) {
-  const { riskScore, riskIndicators } = analysis;
-  const level2 = getRiskLevel(riskScore);
+  const { riskScore, riskIndicators, mlRisk } = analysis;
+  const effectiveScore = mlRisk ? Math.round(mlRisk.risk_probability * 100) : riskScore;
+  const level2 = getRiskLevel(effectiveScore);
   const factors = riskIndicators.filter((i) => i.detected).map((i) => `${i.name}: ${i.description} (+${i.points})`);
+  if (mlRisk) {
+    for (const f of mlRisk.risk_factors) {
+      factors.push(`ML: ${f.factor} (importance: ${(f.importance * 100).toFixed(1)}%)`);
+    }
+  }
   const summary = buildSummary(level2, factors.length);
-  return { score: riskScore, level: level2, summary, factors };
+  return {
+    score: effectiveScore,
+    level: level2,
+    summary,
+    factors,
+    mlScore: mlRisk ? Math.round(mlRisk.risk_probability * 100) : void 0,
+    mlLevel: mlRisk?.risk_level
+  };
 }
 function getRiskLevel(score) {
   if (score <= 20) return "low";
@@ -1138,6 +1544,7 @@ var init_market = __esm({
   "src/core/trends/market.ts"() {
     "use strict";
     init_dexscreener();
+    init_client();
   }
 });
 
@@ -1193,20 +1600,47 @@ async function analyzeSentiment(query) {
     }
     const news = await fetchCryptoNews(query, apiToken);
     if (news.length > 0) {
-      let positiveCount = 0;
-      let negativeCount = 0;
-      for (const article of news) {
-        if (article.sentiment === "positive") positiveCount++;
-        else if (article.sentiment === "negative") negativeCount++;
+      let mlClient2 = getMLClient();
+      if (!mlClient2) {
+        try {
+          const cfg = getConfig();
+          if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+            mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+          }
+        } catch {
+        }
+      }
+      let newsScore;
+      let mlSentiment;
+      let mlConfidence;
+      let mlTopics;
+      if (mlClient2) {
+        const headlines = news.slice(0, 10).map((n) => n.title);
+        const mlResults = await mlClient2.analyzeSentimentBatch(headlines);
+        if (mlResults.length > 0) {
+          const avgScore = mlResults.reduce((s, r) => s + r.score, 0) / mlResults.length;
+          const avgConf = mlResults.reduce((s, r) => s + r.confidence, 0) / mlResults.length;
+          const allTopics = [...new Set(mlResults.flatMap((r) => r.key_topics))];
+          newsScore = avgScore;
+          mlSentiment = avgScore > 0.2 ? "bullish" : avgScore < -0.2 ? "bearish" : "neutral";
+          mlConfidence = avgConf;
+          mlTopics = allTopics.slice(0, 5);
+        } else {
+          newsScore = countBasedScore(news);
+        }
+      } else {
+        newsScore = countBasedScore(news);
       }
       const total = news.length;
-      const newsScore = total > 0 ? (positiveCount - negativeCount) / total : 0;
       sources.push({
-        source: "CryptoPanic News",
+        source: mlSentiment ? "ML NLP Sentiment" : "CryptoPanic News",
         score: newsScore,
         volume: total,
         trending: total > 5,
-        topMentions: news.slice(0, 3).map((n) => n.title)
+        topMentions: news.slice(0, 3).map((n) => n.title),
+        mlSentiment,
+        mlConfidence,
+        mlTopics
       });
     }
   } catch {
@@ -1250,12 +1684,23 @@ async function analyzeSentiment(query) {
   }
   return { overall, sources, consensus };
 }
+function countBasedScore(news) {
+  let pos = 0;
+  let neg = 0;
+  for (const article of news) {
+    if (article.sentiment === "positive") pos++;
+    else if (article.sentiment === "negative") neg++;
+  }
+  const total = news.length;
+  return total > 0 ? (pos - neg) / total : 0;
+}
 var init_sentiment = __esm({
   "src/core/trends/sentiment.ts"() {
     "use strict";
     init_cryptopanic();
     init_dexscreener();
     init_loader();
+    init_client();
   }
 });
 
@@ -1540,15 +1985,74 @@ async function analyzeTechnicals(symbol, timeframe = "4h") {
   }
   const atr = calculateATR(highs, lows, closes);
   if (atr !== null) {
-    const currentPrice = closes[closes.length - 1];
-    signals.push(interpretATR(atr, currentPrice));
+    const currentPrice2 = closes[closes.length - 1];
+    signals.push(interpretATR(atr, currentPrice2));
   }
   const obv = calculateOBV(closes, volumes);
   if (obv !== null) {
-    const priceChange = closes.length >= 2 ? closes[closes.length - 1] - closes[closes.length - 2] : 0;
-    signals.push(interpretOBV(obv, priceChange));
+    const priceChange2 = closes.length >= 2 ? closes[closes.length - 1] - closes[closes.length - 2] : 0;
+    signals.push(interpretOBV(obv, priceChange2));
   }
   const sma20 = calculateSMA(closes, 20);
+  const currentPrice = closes[closes.length - 1];
+  const prevPrice = closes.length >= 2 ? closes[closes.length - 2] : currentPrice;
+  const priceChange = currentPrice - prevPrice;
+  const ema12Val = ema12.length > 0 ? ema12[ema12.length - 1] : 0;
+  const ema26Val = ema26.length > 0 ? ema26[ema26.length - 1] : 0;
+  const emaCrossPct = ema26Val !== 0 ? (ema12Val - ema26Val) / ema26Val * 100 : 0;
+  const atrPct = atr !== null && currentPrice > 0 ? atr / currentPrice * 100 : 0;
+  const bbBandwidth = bb !== null && bb.middle > 0 ? (bb.upper - bb.lower) / bb.middle * 100 : 0;
+  const mlClient2 = getMLClient();
+  if (mlClient2) {
+    try {
+      const mlResult = await mlClient2.interpretTA({
+        rsi: rsi ?? 50,
+        macd_histogram: macd?.histogram ?? 0,
+        macd_line: macd?.macd ?? 0,
+        macd_signal: macd?.signal ?? 0,
+        bb_percent_b: bb?.percentB ?? 0.5,
+        bb_bandwidth: bbBandwidth,
+        ema12: ema12Val,
+        ema26: ema26Val,
+        ema_cross_pct: emaCrossPct,
+        atr: atr ?? 0,
+        atr_pct: atrPct,
+        obv: obv ?? 0,
+        price_change: priceChange
+      });
+      if (mlResult) {
+        const mlSignals = mlResult.signals.map((s) => ({
+          name: s.name,
+          value: 0,
+          signal: s.direction,
+          strength: s.strength,
+          description: s.description
+        }));
+        return {
+          symbol: symbol.toUpperCase(),
+          timeframe,
+          signals: mlSignals,
+          composite: {
+            direction: mlResult.composite.direction,
+            score: mlResult.composite.score,
+            confidence: mlResult.composite.confidence
+          },
+          indicators: {
+            rsi,
+            macd,
+            bollingerBands: bb,
+            ema12: ema12Val || null,
+            ema26: ema26Val || null,
+            sma20: sma20.length > 0 ? sma20[sma20.length - 1] : null,
+            atr,
+            obv
+          },
+          timestamp: Date.now()
+        };
+      }
+    } catch {
+    }
+  }
   const composite = calculateComposite(signals);
   return {
     symbol: symbol.toUpperCase(),
@@ -1559,8 +2063,8 @@ async function analyzeTechnicals(symbol, timeframe = "4h") {
       rsi,
       macd,
       bollingerBands: bb,
-      ema12: ema12.length > 0 ? ema12[ema12.length - 1] : null,
-      ema26: ema26.length > 0 ? ema26[ema26.length - 1] : null,
+      ema12: ema12Val || null,
+      ema26: ema26Val || null,
       sma20: sma20.length > 0 ? sma20[sma20.length - 1] : null,
       atr,
       obv
@@ -1741,6 +2245,7 @@ var init_analyzer = __esm({
     "use strict";
     init_binance();
     init_indicators();
+    init_client();
     WEIGHTS = {
       RSI: 20,
       MACD: 20,
@@ -1800,46 +2305,6 @@ var init_fear_greed = __esm({
   }
 });
 
-// src/utils/logger.ts
-import pino from "pino";
-function createLogger(name) {
-  const isDev = process.env["NODE_ENV"] !== "production";
-  if (isDev) {
-    return pino({
-      name,
-      level,
-      transport: {
-        target: "pino-pretty",
-        options: {
-          colorize: true
-        }
-      }
-    });
-  }
-  return pino({ name, level });
-}
-var level;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    level = process.env["VIZZOR_LOG_LEVEL"] ?? "info";
-  }
-});
-
-// src/ml/client.ts
-function getMLClient() {
-  return mlClient;
-}
-var log, mlClient;
-var init_client = __esm({
-  "src/ml/client.ts"() {
-    "use strict";
-    init_logger();
-    log = createLogger("ml-client");
-    mlClient = null;
-  }
-});
-
 // src/ml/feature-engineer.ts
 async function buildFeatureVector(symbol) {
   const [ta, fundingResult, tickerResult, fgResult, klines] = await Promise.allSettled([
@@ -2035,7 +2500,16 @@ async function generatePrediction(symbol) {
     composite: Math.round(composite),
     disclaimer: "This is not financial advice. Predictions are based on historical data and AI analysis. Always do your own research."
   };
-  const mlClient2 = getMLClient();
+  let mlClient2 = getMLClient();
+  if (!mlClient2) {
+    try {
+      const cfg = getConfig();
+      if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+        mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+      }
+    } catch {
+    }
+  }
   if (mlClient2) {
     try {
       const features = await buildFeatureVector(symbol);
@@ -2074,6 +2548,7 @@ var init_predictor = __esm({
     init_binance();
     init_client();
     init_feature_engineer();
+    init_loader();
     WEIGHTS2 = {
       technical: 40,
       sentiment: 20,
@@ -2162,7 +2637,39 @@ async function analyzeWallet(address, adapter) {
   ]);
   const walletBalance = balance.status === "fulfilled" ? balance.value : 0n;
   const txHistory = transactions.status === "fulfilled" ? transactions.value : [];
-  const patterns = detectPatterns(txHistory.length);
+  const patterns = detectPatterns(txHistory);
+  let mlBehavior;
+  try {
+    let mlClient2 = getMLClient();
+    if (!mlClient2) {
+      try {
+        const cfg = getConfig();
+        if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+          mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+        }
+      } catch {
+      }
+    }
+    if (mlClient2 && txHistory.length > 0) {
+      const features = buildWalletFeatures(txHistory);
+      const result = await mlClient2.classifyWallet(features);
+      if (result) {
+        mlBehavior = result;
+      }
+    }
+  } catch {
+  }
+  let riskLevel = "clean";
+  if (patterns.some((p) => p.severity === "danger")) {
+    riskLevel = "flagged";
+  } else if (patterns.some((p) => p.severity === "warning")) {
+    riskLevel = "suspicious";
+  }
+  if (mlBehavior && mlBehavior.risk_score > 0.6) {
+    riskLevel = "flagged";
+  } else if (mlBehavior && mlBehavior.risk_score > 0.3 && riskLevel === "clean") {
+    riskLevel = "suspicious";
+  }
   return {
     address,
     chain: adapter.chainId,
@@ -2170,23 +2677,129 @@ async function analyzeWallet(address, adapter) {
     transactionCount: txHistory.length,
     tokenBalances: [],
     patterns,
-    riskLevel: patterns.some((p) => p.severity === "danger") ? "flagged" : "clean"
+    riskLevel,
+    mlBehavior
+  };
+}
+function buildWalletFeatures(txHistory) {
+  const txCount = txHistory.length;
+  if (txCount === 0) {
+    return {
+      tx_count: 0,
+      avg_value_eth: 0,
+      max_value_eth: 0,
+      avg_gas_used: 0,
+      unique_recipients: 0,
+      unique_methods: 0,
+      time_span_hours: 0,
+      avg_interval_seconds: 3600,
+      min_interval_seconds: 60,
+      contract_interaction_pct: 0,
+      self_transfer_pct: 0,
+      high_value_tx_pct: 0,
+      failed_tx_pct: 0,
+      token_diversity: 0
+    };
+  }
+  const values = txHistory.map((tx) => Number(tx.value) / 1e18);
+  const gasValues = txHistory.map((tx) => Number(tx.gasUsed ?? 21e3));
+  const recipients = new Set(txHistory.map((tx) => tx.to));
+  const methods = new Set(
+    txHistory.filter((tx) => tx.input && tx.input.length > 10).map((tx) => tx.input.slice(0, 10))
+  );
+  const timestamps = txHistory.map((tx) => tx.timestamp).sort((a, b) => a - b);
+  const timeSpan = timestamps.length > 1 ? (timestamps.at(-1) - timestamps[0]) / 3600 : 0;
+  const intervals = [];
+  for (let i = 1; i < timestamps.length; i++) {
+    intervals.push(timestamps[i] - timestamps[i - 1]);
+  }
+  const selfTxs = txHistory.filter((tx) => tx.from === tx.to).length;
+  const contractTxs = txHistory.filter((tx) => tx.input && tx.input.length > 10).length;
+  const revertedTxs = txHistory.filter((tx) => tx.status === "reverted").length;
+  const highValueTxs = values.filter((v) => v > 10).length;
+  return {
+    tx_count: txCount,
+    avg_value_eth: values.reduce((a, b) => a + b, 0) / txCount,
+    max_value_eth: Math.max(...values),
+    avg_gas_used: gasValues.reduce((a, b) => a + b, 0) / txCount,
+    unique_recipients: recipients.size,
+    unique_methods: methods.size,
+    time_span_hours: timeSpan,
+    avg_interval_seconds: intervals.length > 0 ? intervals.reduce((a, b) => a + b, 0) / intervals.length : 3600,
+    min_interval_seconds: intervals.length > 0 ? Math.min(...intervals) : 60,
+    contract_interaction_pct: contractTxs / txCount,
+    self_transfer_pct: selfTxs / txCount,
+    high_value_tx_pct: highValueTxs / txCount,
+    failed_tx_pct: revertedTxs / txCount,
+    token_diversity: methods.size
   };
 }
-function detectPatterns(txCount) {
+function detectPatterns(txHistory) {
   const patterns = [];
+  const txCount = txHistory.length;
   if (txCount === 0) {
     patterns.push({
       type: "new_wallet",
       description: "Wallet has no transaction history",
       severity: "info"
     });
+    return patterns;
+  }
+  if (txCount > 50) {
+    const timestamps = txHistory.map((tx) => tx.timestamp).sort((a, b) => a - b);
+    const intervals = [];
+    for (let i = 1; i < timestamps.length; i++) {
+      intervals.push(timestamps[i] - timestamps[i - 1]);
+    }
+    const minInterval = Math.min(...intervals);
+    if (minInterval < 5) {
+      patterns.push({
+        type: "rapid_transactions",
+        description: `Extremely rapid transactions detected (${minInterval}s apart) \u2014 possible bot activity`,
+        severity: "warning"
+      });
+    }
+  }
+  const revertedTxs = txHistory.filter((tx) => tx.status === "reverted").length;
+  if (txCount > 10 && revertedTxs / txCount > 0.3) {
+    patterns.push({
+      type: "high_failure_rate",
+      description: `${Math.round(revertedTxs / txCount * 100)}% of transactions failed \u2014 possible sniper or MEV bot`,
+      severity: "warning"
+    });
+  }
+  const values = txHistory.map((tx) => Number(tx.value) / 1e18);
+  const maxValue = Math.max(...values);
+  if (maxValue > 100) {
+    patterns.push({
+      type: "whale_activity",
+      description: `Large transfers detected (max: ${maxValue.toFixed(2)} ETH)`,
+      severity: "info"
+    });
+  }
+  const selfTxs = txHistory.filter((tx) => tx.from === tx.to).length;
+  if (selfTxs / txCount > 0.2) {
+    patterns.push({
+      type: "self_transfers",
+      description: `${Math.round(selfTxs / txCount * 100)}% self-transfers \u2014 possible mixing activity`,
+      severity: "danger"
+    });
+  }
+  const contractTxs = txHistory.filter((tx) => tx.input && tx.input.length > 10).length;
+  if (contractTxs / txCount > 0.9 && txCount > 20) {
+    patterns.push({
+      type: "contract_heavy",
+      description: "Almost exclusively interacts with smart contracts \u2014 automated behavior",
+      severity: "warning"
+    });
   }
   return patterns;
 }
 var init_wallet_analyzer = __esm({
   "src/core/forensics/wallet-analyzer.ts"() {
     "use strict";
+    init_client();
+    init_loader();
   }
 });
 
@@ -2771,8 +3384,6 @@ async function handleConfigInit() {
   console.log(`  3. Try scanning a project:      ${chalk6.cyan("vizzor scan ethereum")}`);
 }
 async function handleConfigSet(key, value) {
-  const configDir = getConfigDir();
-  const configPath = resolve(configDir, "config.yaml");
   const isSensitive = key.toLowerCase().includes("key") || key.toLowerCase().includes("token");
   if (isSensitive) {
     const error = validateKey(key, value);
@@ -2784,20 +3395,12 @@ async function handleConfigSet(key, value) {
       console.log(chalk6.yellow(error));
     }
   }
-  await loadConfig();
-  const config2 = getConfig();
-  const updatedConfig = JSON.parse(JSON.stringify(config2));
-  if (key.includes(".")) {
-    const [section, field] = key.split(".");
-    if (!updatedConfig[section] || typeof updatedConfig[section] !== "object") {
-      updatedConfig[section] = {};
-    }
-    const parsed = field === "maxTokens" ? Number(value) : value;
-    updatedConfig[section][field] = parsed;
-  } else {
-    updatedConfig[key] = value;
+  try {
+    saveConfigValue(key, value);
+  } catch (err) {
+    console.log(chalk6.red(err instanceof Error ? err.message : String(err)));
+    return;
   }
-  writeFileSync2(configPath, yamlStringify(updatedConfig), "utf-8");
   const displayValue = isSensitive ? maskKey(value) : value;
   console.log(chalk6.green(`Set ${key} = ${displayValue}`));
 }
@@ -3780,10 +4383,25 @@ var init_goplus = __esm({
 async function buildContextBlock(userMessage) {
   const lower = userMessage.toLowerCase();
   const sections = [];
-  const addressMatch = userMessage.match(/0x[a-fA-F0-9]{40}/);
+  let mlIntent = null;
+  const mlClientForIntent = getMLClient();
+  if (mlClientForIntent) {
+    try {
+      const intentResult = await mlClientForIntent.classifyIntent(userMessage);
+      if (intentResult && intentResult.confidence > 0.7) {
+        mlIntent = intentResult.intent;
+      }
+    } catch {
+    }
+  }
+  const evmMatch = userMessage.match(/0x[a-fA-F0-9]{40}/);
+  const solanaMatch = userMessage.match(/\b([1-9A-HJ-NP-Za-km-z]{32,44})\b/);
+  const isSolanaAddr = solanaMatch && !evmMatch && /\d/.test(solanaMatch[1]) && solanaMatch[1].length >= 32;
+  const addressMatch = evmMatch ?? (isSolanaAddr ? solanaMatch : null);
+  const detectedChain = evmMatch ? null : isSolanaAddr ? "solana" : null;
   const mentionedTokens = detectTokens(lower);
   const unknownTokens = detectUnknownTokens(userMessage, mentionedTokens);
-  const isAnalysisQuery = matchesAny(lower, ANALYSIS_KEYWORDS);
+  const isAnalysisQuery = matchesAny(lower, ANALYSIS_KEYWORDS) || mlIntent === "analysis";
   const tasks = [];
   if (mentionedTokens.length > 0 || addressMatch || matchesAny(lower, PRICE_KEYWORDS)) {
     tasks.push(
@@ -3809,8 +4427,7 @@ async function buildContextBlock(userMessage) {
     }
   }
   if (addressMatch && isAnalysisQuery) {
-    const cfg = getConfig();
-    const chain = cfg.defaultChain || "ethereum";
+    const chain = detectedChain || getConfig().defaultChain || "ethereum";
     tasks.push(
       fetchSecurityData(addressMatch[0], chain).then((data) => {
         if (data) sections.push(data);
@@ -3851,8 +4468,9 @@ async function buildContextBlock(userMessage) {
       })
     );
   }
-  const isBroadQuery = matchesAny(lower, BROAD_KEYWORDS);
-  if (isBroadQuery) {
+  const isBroadQuery = matchesAny(lower, BROAD_KEYWORDS) || mlIntent === "broad_overview";
+  const hasSpecificIntent = mentionedTokens.length > 0 || unknownTokens.length > 0 || !!addressMatch;
+  if (isBroadQuery && !hasSpecificIntent) {
     if (!matchesAny(lower, TRENDING_KEYWORDS)) {
       tasks.push(
         fetchTrendingData().then((data) => {
@@ -3874,9 +4492,18 @@ async function buildContextBlock(userMessage) {
         })
       );
     }
-    if (!matchesAny(lower, PRICE_KEYWORDS) && mentionedTokens.length === 0 && !addressMatch) {
+    if (!matchesAny(lower, PRICE_KEYWORDS)) {
+      tasks.push(
+        fetchTokenData(["bitcoin", "ethereum", "solana"]).then((data) => {
+          if (data) sections.push(data);
+        })
+      );
+    }
+  } else if (isBroadQuery && hasSpecificIntent) {
+    if (!matchesAny(lower, NEWS_KEYWORDS)) {
+      const symbol = mentionedTokens[0]?.toUpperCase() || unknownTokens[0]?.toUpperCase();
       tasks.push(
-        fetchTokenData(["bitcoin", "ethereum", "solana"]).then((data) => {
+        fetchNewsData(symbol).then((data) => {
           if (data) sections.push(data);
         })
       );
@@ -4158,8 +4785,30 @@ async function fetchNewsData(symbol) {
   try {
     const news = await fetchCryptoNews(symbol, getConfig().cryptopanicApiKey);
     if (news.length > 0) {
+      const headlines = news.slice(0, 8);
       const lines = [`## Latest Crypto News${symbol ? ` (${symbol})` : ""}`];
-      for (const n of news.slice(0, 8)) {
+      const mlClient2 = getMLClient();
+      if (mlClient2) {
+        try {
+          const texts = headlines.map((n) => n.title);
+          const mlResults = await mlClient2.analyzeSentimentBatch(texts);
+          if (mlResults.length > 0) {
+            for (let i = 0; i < headlines.length; i++) {
+              const n = headlines[i];
+              const ml = mlResults[i];
+              const label = ml ? `${ml.sentiment.toUpperCase()} (${(ml.confidence * 100).toFixed(0)}%)` : n.sentiment.toUpperCase();
+              lines.push(`- [${label}] ${n.title} (${n.source.title}, ${n.publishedAt})`);
+            }
+            const avgScore = mlResults.reduce((s, r) => s + r.score, 0) / mlResults.length;
+            const avgSentiment = avgScore > 0.2 ? "BULLISH" : avgScore < -0.2 ? "BEARISH" : "NEUTRAL";
+            lines.push(`
+ML Aggregate Sentiment: ${avgSentiment} (score: ${avgScore.toFixed(3)})`);
+            return lines.join("\n");
+          }
+        } catch {
+        }
+      }
+      for (const n of headlines) {
         lines.push(
           `- [${n.sentiment.toUpperCase()}] ${n.title} (${n.source.title}, ${n.publishedAt})`
         );
@@ -4198,7 +4847,7 @@ async function fetchRaisesData() {
     if (raises.length === 0) return null;
     const lines = ["## Recent Crypto Fundraising Rounds (last 30 days)"];
     for (const r of raises.slice(0, 10)) {
-      const amount = r.amount ? `$${(r.amount / 1e6).toFixed(1)}M` : "undisclosed";
+      const amount = r.amount ? r.amount >= 1e9 ? `$${(r.amount / 1e9).toFixed(1)}B` : r.amount >= 1e6 ? `$${(r.amount / 1e6).toFixed(1)}M` : r.amount >= 1e3 ? `$${(r.amount / 1e3).toFixed(0)}K` : `$${r.amount.toLocaleString()}` : "undisclosed";
       const date = new Date(r.date * 1e3).toISOString().split("T")[0];
       lines.push(
         `- ${r.name} \u2014 ${r.round} (${amount}) on ${r.chains.join(", ") || "multi-chain"} [${date}]${r.leadInvestors.length > 0 ? ` Led by: ${r.leadInvestors.join(", ")}` : ""}`
@@ -5135,6 +5784,7 @@ var init_context_injector = __esm({
     init_goplus();
     init_loader();
     init_constants();
+    init_client();
     PRICE_KEYWORDS = ["price", "worth", "cost", "value", "how much"];
     TRENDING_KEYWORDS = ["trending", "hot", "popular", "top", "best", "hype"];
     NEWS_KEYWORDS = ["news", "latest", "update", "happening", "announcement"];
@@ -5514,6 +6164,7 @@ var DANGEROUS_FUNCTIONS, DANGEROUS_OPCODES;
 var init_bytecode_scanner = __esm({
   "src/core/forensics/bytecode-scanner.ts"() {
     "use strict";
+    init_client();
     DANGEROUS_FUNCTIONS = [
       // Mint functions — inflation risk
       {
@@ -5671,6 +6322,42 @@ async function detectRugIndicators(tokenAddress, adapter) {
     }
   }
   const riskScore = calculateRugRisk(details);
+  let mlAnalysis;
+  try {
+    let mlClient2 = getMLClient();
+    if (!mlClient2) {
+      try {
+        const cfg = getConfig();
+        if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+          mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+        }
+      } catch {
+      }
+    }
+    if (mlClient2) {
+      const mlResult = await mlClient2.predictRug({
+        bytecode_size: hasCode ? code.length : 0,
+        is_verified: hasCode ? 1 : 0,
+        holder_concentration: 0,
+        has_proxy: 0,
+        has_mint: canMint ? 1 : 0,
+        has_pause: canPause ? 1 : 0,
+        has_blacklist: hasBlacklist_ ? 1 : 0,
+        liquidity_locked: 0,
+        buy_tax: 0,
+        sell_tax: 0,
+        contract_age_days: 0,
+        total_transfers: 0,
+        owner_balance_pct: 0,
+        is_open_source: hasCode ? 1 : 0,
+        top10_holder_pct: 0
+      });
+      if (mlResult) {
+        mlAnalysis = mlResult;
+      }
+    }
+  } catch {
+  }
   return {
     isHoneypot: canPause || hasBlacklist_,
     hasLiquidityLock: false,
@@ -5678,8 +6365,9 @@ async function detectRugIndicators(tokenAddress, adapter) {
     ownerCanPause: canPause,
     hasBlacklist: hasBlacklist_,
     highSellTax: false,
-    riskScore,
-    details
+    riskScore: mlAnalysis ? Math.round(riskScore * 0.4 + mlAnalysis.rug_probability * 100 * 0.6) : riskScore,
+    details,
+    mlAnalysis
   };
 }
 function calculateRugRisk(details) {
@@ -5705,6 +6393,83 @@ var init_rug_detector = __esm({
   "src/core/forensics/rug-detector.ts"() {
     "use strict";
     init_bytecode_scanner();
+    init_client();
+    init_loader();
+  }
+});
+
+// src/core/trends/regime.ts
+async function detectMarketRegime(_symbol, features) {
+  const mlClient2 = getMLClient();
+  if (mlClient2) {
+    try {
+      const result = await mlClient2.detectRegime(features);
+      if (result) {
+        return {
+          regime: result.regime,
+          confidence: result.confidence,
+          probabilities: result.probabilities,
+          model: result.model
+        };
+      }
+    } catch {
+    }
+  }
+  return detectRegimeHeuristic(features);
+}
+function detectRegimeHeuristic(features) {
+  const vol = features.volatility_14d;
+  const ret7d = features.returns_7d;
+  const fg = features.fear_greed;
+  const rsi = features.rsi;
+  let regime;
+  let confidence;
+  if (fg < 15 && ret7d < -20) {
+    regime = "capitulation";
+    confidence = 80;
+  } else if (vol > 8) {
+    regime = "volatile";
+    confidence = 70;
+  } else if (vol > 5 && ret7d > 10) {
+    regime = "trending_bull";
+    confidence = 65;
+  } else if (vol > 5 && ret7d < -10) {
+    regime = "trending_bear";
+    confidence = 65;
+  } else if (ret7d > 5 && rsi > 55) {
+    regime = "trending_bull";
+    confidence = 55;
+  } else if (ret7d < -5 && rsi < 45) {
+    regime = "trending_bear";
+    confidence = 55;
+  } else {
+    regime = "ranging";
+    confidence = 60;
+  }
+  const probabilities = {
+    trending_bull: 0.05,
+    trending_bear: 0.05,
+    ranging: 0.05,
+    volatile: 0.05,
+    capitulation: 0.05
+  };
+  probabilities[regime] = confidence / 100;
+  const remaining = 1 - probabilities[regime];
+  const others = Object.keys(probabilities).filter((k) => k !== regime);
+  for (const k of others) {
+    probabilities[k] = remaining / others.length;
+  }
+  return {
+    regime,
+    confidence,
+    probabilities,
+    model: "heuristic-regime-detector"
+  };
+}
+var init_regime = __esm({
+  "src/core/trends/regime.ts"() {
+    "use strict";
+    init_client();
   }
 });
 
@@ -5895,6 +6660,7 @@ var momentumStrategy;
 var init_momentum = __esm({
   "src/core/agent/strategies/momentum.ts"() {
     "use strict";
+    init_client();
     momentumStrategy = {
       name: "momentum",
       description: "RSI reversal + MACD confirmation. Buy oversold bounces, sell overbought peaks.",
@@ -5970,6 +6736,7 @@ var trendFollowingStrategy;
 var init_trend_following = __esm({
   "src/core/agent/strategies/trend-following.ts"() {
     "use strict";
+    init_client();
     trendFollowingStrategy = {
       name: "trend-following",
       description: "EMA crossover trend detection. Buy golden cross, sell death cross.",
@@ -6128,7 +6895,7 @@ var init_ml_adaptive = __esm({
   "src/core/agent/strategies/ml-adaptive.ts"() {
     "use strict";
     init_client();
-    init_feature_engineer();
+    init_regime();
     mlAdaptiveStrategy = {
       name: "ml-adaptive",
       description: "ML-powered strategy using contextual bandit approach. Uses LSTM/RF predictions when available, falls back to rule-based when < 100 training samples.",
@@ -7078,7 +7845,16 @@ async function handleTool(name, input) {
     }
     case "get_ml_prediction": {
       const symbol = String(params["symbol"] ?? "BTC");
-      const mlClient2 = getMLClient();
+      let mlClient2 = getMLClient();
+      if (!mlClient2) {
+        try {
+          const cfg = getConfig();
+          if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+            mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+          }
+        } catch {
+        }
+      }
       if (!mlClient2) {
         const prediction = await generatePrediction(symbol);
         return {
@@ -7139,6 +7915,256 @@ async function handleTool(name, input) {
         }
       };
     }
+    case "get_rug_ml_analysis": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const indicators = await detectRugIndicators(address, adapter);
+      let goplus = null;
+      try {
+        goplus = await checkTokenSecurity(address, chain);
+      } catch {
+      }
+      let mlClient2 = getMLClient();
+      if (!mlClient2) {
+        try {
+          const cfg = getConfig();
+          if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+            mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+          }
+        } catch {
+        }
+      }
+      let mlResult = indicators.mlAnalysis ?? null;
+      if (!mlResult && mlClient2 && goplus) {
+        mlResult = await mlClient2.predictRug({
+          bytecode_size: 0,
+          is_verified: goplus.isOpenSource ? 1 : 0,
+          holder_concentration: (goplus.creatorPercent ?? 0) + (goplus.ownerPercent ?? 0),
+          has_proxy: goplus.isProxy ? 1 : 0,
+          has_mint: goplus.isMintable ? 1 : 0,
+          has_pause: indicators.ownerCanPause ? 1 : 0,
+          has_blacklist: indicators.hasBlacklist ? 1 : 0,
+          liquidity_locked: 0,
+          buy_tax: goplus.buyTax ?? 0,
+          sell_tax: goplus.sellTax ?? 0,
+          contract_age_days: 0,
+          total_transfers: 0,
+          owner_balance_pct: goplus.ownerPercent ?? 0,
+          is_open_source: goplus.isOpenSource ? 1 : 0,
+          top10_holder_pct: 0
+        }) ?? null;
+      }
+      return {
+        address,
+        chain,
+        ruleBasedRiskScore: indicators.riskScore,
+        mlAnalysis: mlResult ?? { note: "ML sidecar not available" },
+        indicators: {
+          isHoneypot: indicators.isHoneypot,
+          ownerCanMint: indicators.ownerCanMint,
+          ownerCanPause: indicators.ownerCanPause,
+          hasBlacklist: indicators.hasBlacklist,
+          highSellTax: indicators.highSellTax
+        },
+        details: indicators.details,
+        goplus: goplus ? {
+          riskLevel: goplus.riskLevel,
+          buyTax: goplus.buyTax,
+          sellTax: goplus.sellTax,
+          isHoneypot: goplus.isHoneypot,
+          isMintable: goplus.isMintable,
+          holderCount: goplus.holderCount
+        } : null
+      };
+    }
+    case "get_wallet_behavior": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const analysis = await analyzeWallet(address, adapter);
+      return {
+        address: analysis.address,
+        chain: analysis.chain,
+        balance: analysis.balance.toString(),
+        transactionCount: analysis.transactionCount,
+        riskLevel: analysis.riskLevel,
+        patterns: analysis.patterns,
+        mlBehavior: analysis.mlBehavior ?? { note: "ML sidecar not available" }
+      };
+    }
+    case "analyze_news_sentiment": {
+      const symbol = String(params["symbol"] ?? "");
+      let mlClient2 = getMLClient();
+      if (!mlClient2) {
+        try {
+          const cfg = getConfig();
+          if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+            mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+          }
+        } catch {
+        }
+      }
+      const news = await fetchCryptoNews(symbol || void 0, getConfig().cryptopanicApiKey);
+      if (news.length === 0) {
+        return { symbol, sentiment: "neutral", note: "No news found" };
+      }
+      const headlines = news.slice(0, 10).map((n) => n.title);
+      if (mlClient2) {
+        const results = await mlClient2.analyzeSentimentBatch(headlines);
+        if (results.length > 0) {
+          const avgScore = results.reduce((s, r) => s + r.score, 0) / results.length;
+          const avgConf = results.reduce((s, r) => s + r.confidence, 0) / results.length;
+          const allTopics = [...new Set(results.flatMap((r) => r.key_topics))];
+          return {
+            symbol,
+            sentiment: avgScore > 0.2 ? "bullish" : avgScore < -0.2 ? "bearish" : "neutral",
+            score: Math.round(avgScore * 1e3) / 1e3,
+            confidence: Math.round(avgConf * 100),
+            topics: allTopics.slice(0, 5),
+            headlines: results.map((r, i) => ({
+              title: headlines[i],
+              sentiment: r.sentiment,
+              score: r.score,
+              confidence: r.confidence
+            })),
+            model: results[0]?.model ?? "unknown",
+            articleCount: news.length
+          };
+        }
+      }
+      let pos = 0;
+      let neg = 0;
+      for (const n of news) {
+        if (n.sentiment === "positive") pos++;
+        else if (n.sentiment === "negative") neg++;
+      }
+      const score = news.length > 0 ? (pos - neg) / news.length : 0;
+      return {
+        symbol,
+        sentiment: score > 0.2 ? "bullish" : score < -0.2 ? "bearish" : "neutral",
+        score,
+        confidence: 50,
+        topics: [],
+        headlines: headlines.map((h, i) => ({
+          title: h,
+          sentiment: news[i]?.sentiment ?? "neutral"
+        })),
+        model: "vote-count-fallback",
+        articleCount: news.length
+      };
+    }
+    case "get_market_regime": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const ta = await analyzeTechnicals(symbol, "4h");
+      const [fgResult, fundingResult] = await Promise.allSettled([
+        fetchFearGreedIndex(1),
+        fetchFundingRate(symbol)
+      ]);
+      const fg = fgResult.status === "fulfilled" ? fgResult.value.current.value : 50;
+      const funding = fundingResult.status === "fulfilled" ? fundingResult.value.fundingRate : 0;
+      const price = ta.indicators.ema12 ?? 0;
+      const atrVal = ta.indicators.atr ?? 0;
+      const atrPct = price > 0 ? atrVal / price * 100 : 3;
+      const regime = await detectMarketRegime(symbol, {
+        returns_1d: 0,
+        returns_7d: 0,
+        volatility_14d: atrPct,
+        volume_ratio: 1,
+        rsi: ta.indicators.rsi ?? 50,
+        bb_width: ta.indicators.bollingerBands ? (ta.indicators.bollingerBands.upper - ta.indicators.bollingerBands.lower) / ta.indicators.bollingerBands.middle * 100 : 0,
+        fear_greed: fg,
+        funding_rate: funding,
+        price_vs_sma200: 0
+      });
+      return {
+        symbol: symbol.toUpperCase(),
+        regime: regime.regime,
+        confidence: regime.confidence,
+        probabilities: regime.probabilities,
+        model: regime.model
+      };
+    }
+    case "get_ta_ml_analysis": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const timeframe = String(params["timeframe"] ?? "4h");
+      const ta = await analyzeTechnicals(symbol, timeframe);
+      return {
+        symbol: ta.symbol,
+        timeframe: ta.timeframe,
+        composite: ta.composite,
+        signals: ta.signals.map((s) => ({
+          name: s.name,
+          signal: s.signal,
+          strength: s.strength,
+          description: s.description
+        })),
+        indicators: {
+          rsi: ta.indicators.rsi ? Math.round(ta.indicators.rsi * 100) / 100 : null,
+          macd: ta.indicators.macd,
+          bollingerBands: ta.indicators.bollingerBands,
+          ema12: ta.indicators.ema12,
+          ema26: ta.indicators.ema26,
+          atr: ta.indicators.atr
+        },
+        note: "ML-enhanced: signals and composite use learned weights when ML sidecar is available"
+      };
+    }
+    case "get_project_risk_ml": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const analysis = await analyzeProject(address, adapter);
+      const risk = assessRisk(analysis);
+      return {
+        address,
+        chain,
+        riskScore: risk.score,
+        riskLevel: risk.level,
+        summary: risk.summary,
+        factors: risk.factors,
+        mlScore: risk.mlScore ?? null,
+        mlLevel: risk.mlLevel ?? null,
+        token: analysis.token ? {
+          name: analysis.token.name,
+          symbol: analysis.token.symbol,
+          decimals: analysis.token.decimals
+        } : null,
+        holderConcentration: analysis.holderConcentration,
+        contractVerified: analysis.contractVerified
+      };
+    }
+    case "get_portfolio_forecast": {
+      const agentName = String(params["agentName"] ?? "");
+      const agent = getAgentByName(agentName);
+      if (!agent) return { error: `Agent "${agentName}" not found` };
+      let mlClient2 = getMLClient();
+      if (!mlClient2) {
+        try {
+          const cfg = getConfig();
+          if (cfg.ml?.enabled && cfg.ml.sidecarUrl) {
+            mlClient2 = initMLClient(cfg.ml.sidecarUrl);
+          }
+        } catch {
+        }
+      }
+      if (!mlClient2) {
+        return {
+          agentName,
+          error: "ML sidecar not available for portfolio forecast"
+        };
+      }
+      const state = getAgentStatus(agent.id);
+      return {
+        agentName,
+        status: state?.status ?? "idle",
+        cycleCount: state?.cycleCount ?? 0,
+        note: "Portfolio forecast requires trade history. Use calculateMetricsWithForecast() in agent engine for full predictions."
+      };
+    }
     case "create_agent": {
       const agentName = String(params["name"] ?? "");
       const strategy = String(params["strategy"] ?? "momentum");
@@ -7215,6 +8241,9 @@ var init_tool_handler = __esm({
     init_fear_greed();
     init_technical_analysis();
     init_predictor();
+    init_regime();
+    init_project_analyzer();
+    init_risk_scorer();
     init_agent();
     init_client();
     init_feature_engineer();
@@ -7508,6 +8537,120 @@ var init_tools = __esm({
           required: []
         }
       },
+      {
+        name: "get_rug_ml_analysis",
+        description: "Run ML-powered rug pull analysis on a token. Uses Gradient Boosted classifier trained on historical rug patterns to predict rug probability, risk level, and key risk factors. Enhanced version of check_rug_indicators with ML scoring.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The token contract address to analyze."
+            },
+            chain: {
+              type: "string",
+              description: "The blockchain the token is deployed on."
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "get_wallet_behavior",
+        description: "ML-powered wallet behavior classification. Uses LSTM model to classify a wallet as: normal_trader, bot, whale, sniper, mev_bot, mixer_user, or rug_deployer. Returns behavior type, confidence, risk score, and behavioral indicators.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The wallet address to classify."
+            },
+            chain: {
+              type: "string",
+              description: "The blockchain the wallet is on."
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "analyze_news_sentiment",
+        description: "ML-powered NLP sentiment analysis on crypto news. Uses DistilBERT model to analyze news headlines for a token, returning bullish/bearish/neutral sentiment, confidence score, and detected topics (regulation, defi, security, etc.).",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'Token symbol to analyze news sentiment for (e.g. "BTC", "ETH").'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_market_regime",
+        description: "Detect the current market regime using ML Hidden Markov Model. Returns regime type (trending_bull, trending_bear, ranging, volatile, capitulation), confidence, and probability distribution across all regimes. Uses HMM when available, falls back to heuristic analysis.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_ta_ml_analysis",
+        description: "Run ML-enhanced technical analysis with learned signal weights. Uses Random Forest to interpret RSI, MACD, Bollinger Bands, EMA crossover, ATR, OBV simultaneously. Returns signals with ML-derived importance weights and composite direction. More accurate than static weight TA.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+            },
+            timeframe: {
+              type: "string",
+              description: 'Kline interval: "1h", "4h", "1d". Defaults to "4h".'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_project_risk_ml",
+        description: "Run ML-powered project risk scoring on a token. Uses GBM classifier trained on contract features (verification, holder concentration, taxes, mint/pause/blacklist capabilities) to predict overall project risk probability and identify top risk factors.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The token contract address to analyze."
+            },
+            chain: {
+              type: "string",
+              description: "The blockchain the token is deployed on."
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "get_portfolio_forecast",
+        description: "Generate forward-looking portfolio performance predictions using ML. Analyzes trade history to predict next-period return, Sharpe ratio, and max drawdown. Requires at least 10 completed trades.",
+        input_schema: {
+          type: "object",
+          properties: {
+            agentName: {
+              type: "string",
+              description: "The trading agent name to forecast for."
+            }
+          },
+          required: ["agentName"]
+        }
+      },
       {
         name: "create_agent",
         description: "Create an autonomous trading agent that monitors crypto pairs using a strategy (momentum or trend-following). Returns the created agent config.",
@@ -9726,9 +10869,19 @@ var init_price_ticker = __esm({
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function WelcomeBanner() {
-  return /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, color: "blue", children: "vizzor" }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " v0.1.0 \u2014 crypto chronovisor. Type /help for commands." })
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "  " }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "blue", children: "vizzor" }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: " v0.10.0" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " \u2014 AI-powered crypto chronovisor" })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  ML models: LSTM + Random Forest + Isolation Forest + GBM Rug + Wallet LSTM + DistilBERT NLP" }) }),
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  Type " }),
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "/help" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " for commands or ask anything about crypto." })
+    ] })
   ] });
 }
 var init_welcome_banner = __esm({
@@ -11412,7 +12565,7 @@ collectCmd.command("status").description("Show data collection status").action(a
   const { handleCollectStatus: handleCollectStatus2 } = await Promise.resolve().then(() => (init_collect(), collect_exports));
   handleCollectStatus2();
 });
-program.command("serve").description("Start the REST API server").option("--port <port>", "Server port", parseInt, 3e3).option("--host <host>", "Server host", "0.0.0.0").option("--auth", "Enable API key authentication", false).action(async (options) => {
+program.command("serve").description("Start the REST API server").option("--port <port>", "Server port", (v) => parseInt(v, 10), 3e3).option("--host <host>", "Server host", "0.0.0.0").option("--auth", "Enable API key authentication", false).action(async (options) => {
   const { handleServe: handleServe2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
   await handleServe2(options);
 });