@vizzor/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -46,6 +46,19 @@ var init_schema = __esm({
         walletData: z.number().default(600),
         contractCode: z.number().default(86400)
       }).default(() => ({ tokenInfo: 3600, marketData: 300, walletData: 600, contractCode: 86400 })),
+      database: z.object({
+        type: z.enum(["sqlite", "postgres"]).default("sqlite"),
+        url: z.string().optional()
+      }).default(() => ({ type: "sqlite" })),
+      ml: z.object({
+        enabled: z.boolean().default(false),
+        sidecarUrl: z.string().default("http://localhost:8000"),
+        fallbackToRules: z.boolean().default(true)
+      }).default(() => ({
+        enabled: false,
+        sidecarUrl: "http://localhost:8000",
+        fallbackToRules: true
+      })),
       discordToken: z.string().optional(),
       discordGuildId: z.string().optional(),
       telegramToken: z.string().optional()
@@ -643,12 +656,12 @@ var init_adapter = __esm({
           toBlock: options?.toBlock,
           args: options?.args
         });
-        return logs.map((log) => ({
-          eventName: log.eventName ?? eventName,
-          blockNumber: log.blockNumber ?? 0n,
-          transactionHash: log.transactionHash ?? "0x",
-          args: log.args ?? {},
-          logIndex: log.logIndex ?? 0
+        return logs.map((log3) => ({
+          eventName: log3.eventName ?? eventName,
+          blockNumber: log3.blockNumber ?? 0n,
+          transactionHash: log3.transactionHash ?? "0x",
+          args: log3.args ?? {},
+          logIndex: log3.logIndex ?? 0
         }));
       }
       // ── Tokens ──────────────────────────────────────────────────────────────
@@ -1710,6 +1723,111 @@ 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([
+    analyzeTechnicals(symbol, "4h"),
+    fetchFundingRate(symbol),
+    fetchTickerPrice(symbol),
+    fetchFearGreedIndex(1),
+    fetchKlines(symbol, "4h", 100)
+  ]);
+  const indicators = ta.status === "fulfilled" ? ta.value.indicators : null;
+  const funding = fundingResult.status === "fulfilled" ? fundingResult.value : null;
+  const ticker = tickerResult.status === "fulfilled" ? tickerResult.value : null;
+  const fg = fgResult.status === "fulfilled" ? fgResult.value : null;
+  const candles = klines.status === "fulfilled" ? klines.value : [];
+  let rsiSlope = 0;
+  if (candles.length >= 17) {
+    const closes = candles.map((k) => k.close);
+    const recentRsi = calculateRSI(closes, 14);
+    const olderCloses = closes.slice(0, -3);
+    const olderRsi = calculateRSI(olderCloses, 14);
+    if (recentRsi !== null && olderRsi !== null) {
+      rsiSlope = recentRsi - olderRsi;
+    }
+  }
+  let volumeRatio = 1;
+  if (candles.length >= 21) {
+    const currentVolume = candles[candles.length - 1].volume;
+    const avgVolume = candles.slice(-21, -1).reduce((sum, k) => sum + k.volume, 0) / 20;
+    volumeRatio = avgVolume > 0 ? currentVolume / avgVolume : 1;
+  }
+  const price = ticker?.price ?? candles[candles.length - 1]?.close ?? 0;
+  const ema12 = indicators?.ema12 ?? 0;
+  const ema26 = indicators?.ema26 ?? 0;
+  const emaCrossoverPct = price > 0 ? (ema12 - ema26) / price * 100 : 0;
+  const atr = indicators?.atr ?? 0;
+  const atrPct = price > 0 ? atr / price * 100 : 0;
+  return {
+    rsi: indicators?.rsi ?? 50,
+    macdHistogram: indicators?.macd?.histogram ?? 0,
+    bollingerPercentB: indicators?.bollingerBands?.percentB ?? 0.5,
+    ema12,
+    ema26,
+    atr,
+    obv: indicators?.obv ?? 0,
+    fundingRate: funding?.fundingRate ?? 0,
+    fearGreed: fg?.current.value ?? 50,
+    priceChange24h: ticker?.change24h ?? 0,
+    rsiSlope,
+    volumeRatio,
+    emaCrossoverPct,
+    atrPct,
+    symbol: symbol.toUpperCase(),
+    timestamp: Date.now()
+  };
+}
+var init_feature_engineer = __esm({
+  "src/ml/feature-engineer.ts"() {
+    "use strict";
+    init_technical_analysis();
+    init_binance();
+    init_fear_greed();
+    init_indicators();
+  }
+});
+
 // src/core/trends/predictor.ts
 async function generatePrediction(symbol) {
   const reasoning = [];
@@ -1830,7 +1948,7 @@ async function generatePrediction(symbol) {
   const negativeCount = signalValues.filter((v) => v < 0).length;
   const agreement = Math.max(positiveCount, negativeCount) / Math.max(1, positiveCount + negativeCount);
   const confidence = Math.round(Math.min(95, completeness / 5 * agreement * 100));
-  return {
+  const rulePrediction = {
     symbol: symbol.toUpperCase(),
     direction,
     confidence,
@@ -1840,6 +1958,34 @@ 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();
+  if (mlClient2) {
+    try {
+      const features = await buildFeatureVector(symbol);
+      const mlPred = await mlClient2.predict(features);
+      if (mlPred) {
+        return mergePredictions(rulePrediction, mlPred);
+      }
+    } catch {
+    }
+  }
+  return rulePrediction;
+}
+function mergePredictions(rule, ml) {
+  const mlComposite = ml.direction === "up" ? ml.probability * 100 : ml.direction === "down" ? -(ml.probability * 100) : 0;
+  const mergedComposite = Math.round(rule.composite * 0.4 + mlComposite * 0.6);
+  const mergedDirection = mergedComposite > 15 ? "up" : mergedComposite < -15 ? "down" : "sideways";
+  const mergedConfidence = Math.round(Math.min(95, rule.confidence * 0.4 + ml.confidence * 0.6));
+  return {
+    ...rule,
+    direction: mergedDirection,
+    confidence: mergedConfidence,
+    composite: mergedComposite,
+    reasoning: [
+      ...rule.reasoning,
+      `ML (${ml.model}): ${ml.direction} with ${(ml.probability * 100).toFixed(1)}% probability (horizon: ${ml.horizon})`
+    ]
+  };
 }
 var WEIGHTS2;
 var init_predictor = __esm({
@@ -1849,6 +1995,8 @@ var init_predictor = __esm({
     init_sentiment();
     init_fear_greed();
     init_binance();
+    init_client();
+    init_feature_engineer();
     WEIGHTS2 = {
       technical: 40,
       sentiment: 20,
@@ -2561,7 +2709,17 @@ async function handleConfigSet(key, value) {
   }
   await loadConfig();
   const config2 = getConfig();
-  const updatedConfig = { ...config2, [key]: value };
+  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;
+  }
   writeFileSync2(configPath, yamlStringify(updatedConfig), "utf-8");
   const displayValue = isSensitive ? maskKey(value) : value;
   console.log(chalk6.green(`Set ${key} = ${displayValue}`));
@@ -5219,7 +5377,7 @@ async function analyze(systemPrompt, userMessage, tools) {
   return p.analyze(systemPrompt, userMessage, tools, toolHandler);
 }
 var provider, config, toolHandler;
-var init_client = __esm({
+var init_client2 = __esm({
   "src/ai/client.ts"() {
     "use strict";
     init_registry2();
@@ -5514,6 +5672,26 @@ function getDb() {
   `);
   return db;
 }
+function getCached(key) {
+  const row = getDb().prepare("SELECT value, expires_at FROM cache WHERE key = ?").get(key);
+  if (!row) {
+    return null;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (row.expires_at <= now) {
+    getDb().prepare("DELETE FROM cache WHERE key = ?").run(key);
+    return null;
+  }
+  return JSON.parse(row.value);
+}
+function setCache(key, value, ttlSeconds) {
+  const now = Math.floor(Date.now() / 1e3);
+  const expiresAt = now + ttlSeconds;
+  getDb().prepare(
+    `INSERT OR REPLACE INTO cache (key, value, expires_at, created_at)
+       VALUES (?, ?, ?, ?)`
+  ).run(key, JSON.stringify(value), expiresAt, now);
+}
 var db;
 var init_cache = __esm({
   "src/data/cache.ts"() {
@@ -5523,32 +5701,6 @@ var init_cache = __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/core/agent/engine.ts
 var logger, AgentEngine;
 var init_engine = __esm({
@@ -6019,6 +6171,436 @@ var init_agent = __esm({
   }
 });
 
+// src/data/sqlite-store.ts
+function ensureAgentTables2() {
+  const db2 = getDb();
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      strategy TEXT NOT NULL,
+      pairs TEXT NOT NULL,
+      interval_seconds INTEGER NOT NULL DEFAULT 60,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS agent_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      action TEXT NOT NULL,
+      confidence INTEGER NOT NULL,
+      reasoning TEXT NOT NULL,
+      signals TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    )
+  `);
+}
+function rowToConfig(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    strategy: row.strategy,
+    pairs: JSON.parse(row.pairs),
+    interval: row.interval_seconds,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var SqliteStore;
+var init_sqlite_store = __esm({
+  "src/data/sqlite-store.ts"() {
+    "use strict";
+    init_cache();
+    SqliteStore = class {
+      // ---- Cache ---------------------------------------------------------------
+      async getCached(key) {
+        return getCached(key);
+      }
+      async setCache(key, value, ttlSeconds) {
+        setCache(key, value, ttlSeconds);
+      }
+      // ---- Agents --------------------------------------------------------------
+      async createAgent(config2) {
+        ensureAgentTables2();
+        getDb().prepare(
+          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          config2.id,
+          config2.name,
+          config2.strategy,
+          JSON.stringify(config2.pairs),
+          config2.interval,
+          config2.createdAt,
+          config2.updatedAt
+        );
+        return config2;
+      }
+      async listAgents() {
+        ensureAgentTables2();
+        const rows = getDb().prepare("SELECT * FROM agents ORDER BY created_at DESC").all();
+        return rows.map(rowToConfig);
+      }
+      async getAgentById(id) {
+        ensureAgentTables2();
+        const row = getDb().prepare("SELECT * FROM agents WHERE id = ?").get(id);
+        return row ? rowToConfig(row) : null;
+      }
+      async getAgentByName(name) {
+        ensureAgentTables2();
+        const row = getDb().prepare("SELECT * FROM agents WHERE name = ?").get(name);
+        return row ? rowToConfig(row) : null;
+      }
+      async deleteAgent(id) {
+        ensureAgentTables2();
+        const result = getDb().prepare("DELETE FROM agents WHERE id = ?").run(id);
+        getDb().prepare("DELETE FROM agent_decisions WHERE agent_id = ?").run(id);
+        return result.changes > 0;
+      }
+      async logDecision(result) {
+        ensureAgentTables2();
+        getDb().prepare(
+          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          result.agentId,
+          result.symbol,
+          result.decision.action,
+          result.decision.confidence,
+          JSON.stringify(result.decision.reasoning),
+          JSON.stringify(result.signals),
+          result.timestamp
+        );
+      }
+      async getDecisions(agentId, limit) {
+        ensureAgentTables2();
+        const rows = getDb().prepare("SELECT * FROM agent_decisions WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?").all(agentId, limit);
+        return rows.map((r) => ({
+          agentId: r.agent_id,
+          symbol: r.symbol,
+          timestamp: r.created_at,
+          signals: JSON.parse(r.signals),
+          decision: {
+            action: r.action,
+            confidence: r.confidence,
+            reasoning: JSON.parse(r.reasoning)
+          }
+        }));
+      }
+      // ---- Time-series (no-op for SQLite) --------------------------------------
+      async insertOHLCV(_records) {
+      }
+      async queryOHLCV(_symbol, _timeframe, _from, _to) {
+        return [];
+      }
+      // ---- Predictions (no-op for SQLite) --------------------------------------
+      async logPrediction(_prediction) {
+      }
+      async getPredictionAccuracy(_model, _days) {
+        return {
+          model: _model,
+          totalPredictions: 0,
+          correctPredictions: 0,
+          accuracy: 0,
+          byDirection: {
+            up: { total: 0, correct: 0, accuracy: 0 },
+            down: { total: 0, correct: 0, accuracy: 0 },
+            sideways: { total: 0, correct: 0, accuracy: 0 }
+          },
+          period: `${_days}d`
+        };
+      }
+      // ---- Lifecycle -----------------------------------------------------------
+      async close() {
+      }
+    };
+  }
+});
+
+// src/data/postgres-store.ts
+var postgres_store_exports = {};
+__export(postgres_store_exports, {
+  PostgresStore: () => PostgresStore
+});
+import pg from "pg";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename, __dirname, PostgresStore;
+var init_postgres_store = __esm({
+  "src/data/postgres-store.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    PostgresStore = class {
+      pool;
+      initialized = false;
+      constructor(connectionUrl) {
+        this.pool = new pg.Pool({ connectionString: connectionUrl, max: 10 });
+      }
+      async init() {
+        if (this.initialized) return;
+        const migrationPath = resolve2(__dirname, "migrations", "001-init.sql");
+        const sql = readFileSync2(migrationPath, "utf-8");
+        await this.pool.query(sql);
+        this.initialized = true;
+      }
+      async query(text, params) {
+        await this.init();
+        return this.pool.query(text, params);
+      }
+      // ---- Cache ---------------------------------------------------------------
+      async getCached(key) {
+        const now = Math.floor(Date.now() / 1e3);
+        const { rows } = await this.query(
+          "SELECT value FROM cache WHERE key = $1 AND expires_at > $2",
+          [key, now]
+        );
+        if (rows.length === 0) return null;
+        return rows[0].value;
+      }
+      async setCache(key, value, ttlSeconds) {
+        const now = Math.floor(Date.now() / 1e3);
+        const expiresAt = now + ttlSeconds;
+        await this.query(
+          `INSERT INTO cache (key, value, expires_at, created_at)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (key) DO UPDATE SET value = $2, expires_at = $3`,
+          [key, JSON.stringify(value), expiresAt, now]
+        );
+      }
+      // ---- Agents --------------------------------------------------------------
+      async createAgent(config2) {
+        await this.query(
+          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            config2.id,
+            config2.name,
+            config2.strategy,
+            JSON.stringify(config2.pairs),
+            config2.interval,
+            config2.createdAt,
+            config2.updatedAt
+          ]
+        );
+        return config2;
+      }
+      async listAgents() {
+        const { rows } = await this.query("SELECT * FROM agents ORDER BY created_at DESC");
+        return rows.map((r) => ({
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        }));
+      }
+      async getAgentById(id) {
+        const { rows } = await this.query("SELECT * FROM agents WHERE id = $1", [id]);
+        if (rows.length === 0) return null;
+        const r = rows[0];
+        return {
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        };
+      }
+      async getAgentByName(name) {
+        const { rows } = await this.query("SELECT * FROM agents WHERE name = $1", [name]);
+        if (rows.length === 0) return null;
+        const r = rows[0];
+        return {
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        };
+      }
+      async deleteAgent(id) {
+        const result = await this.query("DELETE FROM agents WHERE id = $1", [id]);
+        return (result.rowCount ?? 0) > 0;
+      }
+      async logDecision(result) {
+        await this.query(
+          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            result.agentId,
+            result.symbol,
+            result.decision.action,
+            result.decision.confidence,
+            JSON.stringify(result.decision.reasoning),
+            JSON.stringify(result.signals),
+            result.timestamp
+          ]
+        );
+      }
+      async getDecisions(agentId, limit) {
+        const { rows } = await this.query("SELECT * FROM agent_decisions WHERE agent_id = $1 ORDER BY created_at DESC LIMIT $2", [
+          agentId,
+          limit
+        ]);
+        return rows.map((r) => ({
+          agentId: r.agent_id,
+          symbol: r.symbol,
+          timestamp: Number(r.created_at),
+          signals: typeof r.signals === "string" ? JSON.parse(r.signals) : r.signals,
+          decision: {
+            action: r.action,
+            confidence: r.confidence,
+            reasoning: typeof r.reasoning === "string" ? JSON.parse(r.reasoning) : r.reasoning
+          }
+        }));
+      }
+      // ---- Time-series ---------------------------------------------------------
+      async insertOHLCV(records) {
+        if (records.length === 0) return;
+        const values = [];
+        const placeholders = [];
+        for (let i = 0; i < records.length; i++) {
+          const r = records[i];
+          const offset = i * 9;
+          placeholders.push(
+            `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`
+          );
+          values.push(
+            new Date(r.time).toISOString(),
+            r.symbol,
+            r.timeframe,
+            r.open,
+            r.high,
+            r.low,
+            r.close,
+            r.volume,
+            r.trades
+          );
+        }
+        await this.query(
+          `INSERT INTO ohlcv (time, symbol, timeframe, open, high, low, close, volume, trades)
+       VALUES ${placeholders.join(", ")}
+       ON CONFLICT (symbol, timeframe, time) DO UPDATE
+       SET open = EXCLUDED.open, high = EXCLUDED.high, low = EXCLUDED.low,
+           close = EXCLUDED.close, volume = EXCLUDED.volume, trades = EXCLUDED.trades`,
+          values
+        );
+      }
+      async queryOHLCV(symbol, timeframe, from, to) {
+        const { rows } = await this.query(
+          `SELECT * FROM ohlcv
+       WHERE symbol = $1 AND timeframe = $2 AND time >= $3 AND time <= $4
+       ORDER BY time ASC`,
+          [symbol, timeframe, new Date(from).toISOString(), new Date(to).toISOString()]
+        );
+        return rows.map((r) => ({
+          time: new Date(r.time).getTime(),
+          symbol: r.symbol,
+          timeframe: r.timeframe,
+          open: r.open,
+          high: r.high,
+          low: r.low,
+          close: r.close,
+          volume: r.volume,
+          trades: r.trades
+        }));
+      }
+      // ---- Predictions ---------------------------------------------------------
+      async logPrediction(prediction) {
+        await this.query(
+          `INSERT INTO predictions (symbol, model, direction, probability, horizon, features, predicted_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            prediction.symbol,
+            prediction.model,
+            prediction.direction,
+            prediction.probability,
+            prediction.horizon,
+            JSON.stringify(prediction.features),
+            new Date(prediction.predictedAt).toISOString()
+          ]
+        );
+      }
+      async getPredictionAccuracy(model, days) {
+        const since = new Date(Date.now() - days * 864e5).toISOString();
+        const { rows: totals } = await this.query(
+          `SELECT direction,
+              COUNT(*)::text AS total,
+              COUNT(*) FILTER (WHERE was_correct = true)::text AS correct
+       FROM predictions
+       WHERE model = $1 AND predicted_at >= $2 AND was_correct IS NOT NULL
+       GROUP BY direction`,
+          [model, since]
+        );
+        const byDir = {
+          up: { total: 0, correct: 0, accuracy: 0 },
+          down: { total: 0, correct: 0, accuracy: 0 },
+          sideways: { total: 0, correct: 0, accuracy: 0 }
+        };
+        let totalAll = 0;
+        let correctAll = 0;
+        for (const row of totals) {
+          const t = parseInt(row.total, 10);
+          const c = parseInt(row.correct, 10);
+          totalAll += t;
+          correctAll += c;
+          const dir = row.direction;
+          if (byDir[dir]) {
+            byDir[dir] = { total: t, correct: c, accuracy: t > 0 ? c / t : 0 };
+          }
+        }
+        return {
+          model,
+          totalPredictions: totalAll,
+          correctPredictions: correctAll,
+          accuracy: totalAll > 0 ? correctAll / totalAll : 0,
+          byDirection: byDir,
+          period: `${days}d`
+        };
+      }
+      // ---- Lifecycle -----------------------------------------------------------
+      async close() {
+        await this.pool.end();
+      }
+    };
+  }
+});
+
+// src/data/store-factory.ts
+async function getStore(config2) {
+  if (instance) return instance;
+  if (config2.database?.type === "postgres" && config2.database.url) {
+    const { PostgresStore: PostgresStore2 } = await Promise.resolve().then(() => (init_postgres_store(), postgres_store_exports));
+    instance = new PostgresStore2(config2.database.url);
+  } else {
+    instance = new SqliteStore();
+  }
+  return instance;
+}
+function getStoreInstance() {
+  return instance;
+}
+var instance;
+var init_store_factory = __esm({
+  "src/data/store-factory.ts"() {
+    "use strict";
+    init_sqlite_store();
+    instance = null;
+  }
+});
+
 // src/ai/tool-handler.ts
 async function handleTool(name, input) {
   const params = input;
@@ -6315,6 +6897,69 @@ async function handleTool(name, input) {
         disclaimer: prediction.disclaimer
       };
     }
+    case "get_ml_prediction": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const mlClient2 = getMLClient();
+      if (!mlClient2) {
+        const prediction = await generatePrediction(symbol);
+        return {
+          ...prediction,
+          mlAvailable: false,
+          note: "ML sidecar not configured; using rule-based prediction"
+        };
+      }
+      const features = await buildFeatureVector(symbol);
+      const mlPred = await mlClient2.predict(features);
+      if (!mlPred) {
+        const prediction = await generatePrediction(symbol);
+        return {
+          ...prediction,
+          mlAvailable: false,
+          note: "ML sidecar unavailable; using rule-based prediction"
+        };
+      }
+      return {
+        symbol: mlPred.symbol,
+        direction: mlPred.direction,
+        probability: mlPred.probability,
+        confidence: mlPred.confidence,
+        model: mlPred.model,
+        horizon: mlPred.horizon,
+        mlAvailable: true,
+        features: {
+          rsi: features.rsi,
+          macdHistogram: features.macdHistogram,
+          bollingerPercentB: features.bollingerPercentB,
+          fundingRate: features.fundingRate,
+          fearGreed: features.fearGreed,
+          rsiSlope: features.rsiSlope,
+          volumeRatio: features.volumeRatio,
+          emaCrossoverPct: features.emaCrossoverPct,
+          atrPct: features.atrPct
+        }
+      };
+    }
+    case "get_model_accuracy": {
+      const model = String(params["model"] ?? "lstm-predictor");
+      const days = params["days"] ? Number(params["days"]) : 30;
+      const store = getStoreInstance();
+      if (!store) {
+        return { error: "DataStore not initialized. ML accuracy requires PostgreSQL backend." };
+      }
+      const accuracy = await store.getPredictionAccuracy(model, days);
+      return {
+        model: accuracy.model,
+        period: accuracy.period,
+        totalPredictions: accuracy.totalPredictions,
+        correctPredictions: accuracy.correctPredictions,
+        accuracy: `${(accuracy.accuracy * 100).toFixed(1)}%`,
+        byDirection: {
+          up: `${(accuracy.byDirection.up.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.up.correct}/${accuracy.byDirection.up.total})`,
+          down: `${(accuracy.byDirection.down.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.down.correct}/${accuracy.byDirection.down.total})`,
+          sideways: `${(accuracy.byDirection.sideways.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.sideways.correct}/${accuracy.byDirection.sideways.total})`
+        }
+      };
+    }
     case "create_agent": {
       const agentName = String(params["name"] ?? "");
       const strategy = String(params["strategy"] ?? "momentum");
@@ -6392,6 +7037,9 @@ var init_tool_handler = __esm({
     init_technical_analysis();
     init_predictor();
     init_agent();
+    init_client();
+    init_feature_engineer();
+    init_store_factory();
   }
 });
 
@@ -6649,6 +7297,38 @@ var init_tools = __esm({
           required: ["symbol"]
         }
       },
+      {
+        name: "get_ml_prediction",
+        description: "Get an ML-enhanced prediction using LSTM/Random Forest models from the ML sidecar. Returns direction, probability, model confidence, and feature importance. Falls back to rule-based prediction if ML sidecar is unavailable.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_model_accuracy",
+        description: "Get historical accuracy metrics for ML prediction models. Shows total predictions, accuracy percentage, and breakdown by direction (up/down/sideways).",
+        input_schema: {
+          type: "object",
+          properties: {
+            model: {
+              type: "string",
+              description: 'Model name (e.g. "lstm-predictor", "signal-classifier"). Defaults to "lstm-predictor".'
+            },
+            days: {
+              type: "number",
+              description: "Number of days to look back for accuracy stats. Defaults to 30."
+            }
+          },
+          required: []
+        }
+      },
       {
         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.",
@@ -7311,7 +7991,7 @@ var init_bot = __esm({
   "src/discord/bot.ts"() {
     "use strict";
     init_loader();
-    init_client();
+    init_client2();
     init_tool_handler();
     init_tools();
     init_chat();
@@ -7993,7 +8673,7 @@ var init_bot2 = __esm({
   "src/telegram/bot.ts"() {
     "use strict";
     init_loader();
-    init_client();
+    init_client2();
     init_tool_handler();
     init_tools();
     init_chat();
@@ -8048,40 +8728,18 @@ function handleBotValidate() {
   const config2 = getConfig();
   console.log(chalk7.bold("\nVizzor Bot Configuration Check\n"));
   const checks = [
-    {
-      label: "Anthropic API Key",
-      value: config2.anthropicApiKey,
-      required: true,
-      key: "anthropicApiKey"
-    },
-    {
-      label: "Etherscan API Key",
-      value: config2.etherscanApiKey,
-      required: true,
-      key: "etherscanApiKey"
-    },
-    { label: "Discord Token", value: config2.discordToken, required: false, key: "discordToken" },
-    {
-      label: "Discord Guild ID",
-      value: config2.discordGuildId,
-      required: false,
-      key: "discordGuildId"
-    },
-    { label: "Telegram Token", value: config2.telegramToken, required: false, key: "telegramToken" },
-    {
-      label: "CryptoPanic Key",
-      value: config2.cryptopanicApiKey,
-      required: false,
-      key: "cryptopanicApiKey"
-    }
+    { label: "Anthropic API Key", isSet: hasKey(config2.anthropicApiKey), required: true },
+    { label: "Etherscan API Key", isSet: hasKey(config2.etherscanApiKey), required: true },
+    { label: "Discord Token", isSet: hasKey(config2.discordToken), required: false },
+    { label: "Discord Guild ID", isSet: hasKey(config2.discordGuildId), required: false },
+    { label: "Telegram Token", isSet: hasKey(config2.telegramToken), required: false },
+    { label: "CryptoPanic Key", isSet: hasKey(config2.cryptopanicApiKey), required: false }
   ];
   let allRequired = true;
   for (const check of checks) {
-    const set = hasKey(check.value);
-    const status = set ? chalk7.green("OK") : check.required ? chalk7.red("MISSING") : chalk7.yellow("NOT SET");
-    const masked = set ? maskKey(check.value) : chalk7.dim("(not set)");
-    console.log(`  ${status.padEnd(18)} ${check.label.padEnd(20)} ${masked}`);
-    if (check.required && !set) allRequired = false;
+    const status = check.isSet ? chalk7.green("OK") : check.required ? chalk7.red("MISSING") : chalk7.yellow("NOT SET");
+    console.log(`  ${status.padEnd(18)} ${check.label}`);
+    if (check.required && !check.isSet) allRequired = false;
   }
   console.log();
   if (hasKey(config2.discordToken)) {
@@ -8114,6 +8772,186 @@ var init_bot3 = __esm({
   }
 });
 
+// src/data/collector.ts
+var log2, MAJOR_SYMBOLS, TIMEFRAMES, COLLECTION_INTERVAL_MS, DataCollector;
+var init_collector = __esm({
+  "src/data/collector.ts"() {
+    "use strict";
+    init_binance();
+    init_logger();
+    log2 = createLogger("collector");
+    MAJOR_SYMBOLS = [
+      "BTC",
+      "ETH",
+      "SOL",
+      "BNB",
+      "XRP",
+      "ADA",
+      "DOGE",
+      "DOT",
+      "AVAX",
+      "MATIC",
+      "LINK",
+      "UNI",
+      "ATOM",
+      "NEAR",
+      "ARB",
+      "OP",
+      "SUI",
+      "APT",
+      "PEPE",
+      "SHIB",
+      "FLOKI",
+      "BONK",
+      "WIF"
+    ];
+    TIMEFRAMES = ["1h", "4h"];
+    COLLECTION_INTERVAL_MS = 5 * 60 * 1e3;
+    DataCollector = class {
+      constructor(store, symbols = MAJOR_SYMBOLS, intervalMs = COLLECTION_INTERVAL_MS) {
+        this.store = store;
+        this.symbols = symbols;
+        this.intervalMs = intervalMs;
+        this.status.symbols = symbols;
+        this.status.intervalMs = intervalMs;
+      }
+      timer = null;
+      status = {
+        running: false,
+        symbols: MAJOR_SYMBOLS,
+        timeframes: [...TIMEFRAMES],
+        intervalMs: COLLECTION_INTERVAL_MS,
+        lastRun: null,
+        totalRecords: 0,
+        errors: 0
+      };
+      getStatus() {
+        return { ...this.status };
+      }
+      start() {
+        if (this.status.running) {
+          log2.warn("Collector already running");
+          return;
+        }
+        log2.info(
+          `Starting data collector: ${this.symbols.length} symbols, ${TIMEFRAMES.length} timeframes, every ${this.intervalMs / 1e3}s`
+        );
+        this.status.running = true;
+        void this.collectAll();
+        this.timer = setInterval(() => void this.collectAll(), this.intervalMs);
+      }
+      stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+        this.status.running = false;
+        log2.info("Data collector stopped");
+      }
+      async collectAll() {
+        log2.info("Collection cycle starting");
+        const start = Date.now();
+        for (const timeframe of TIMEFRAMES) {
+          for (const symbol of this.symbols) {
+            try {
+              await this.collectSymbol(symbol, timeframe);
+            } catch (err) {
+              this.status.errors++;
+              log2.error(
+                `Failed to collect ${symbol}/${timeframe}: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+        this.status.lastRun = Date.now();
+        const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+        log2.info(
+          `Collection cycle complete in ${elapsed}s (total records: ${this.status.totalRecords})`
+        );
+      }
+      async collectSymbol(symbol, timeframe) {
+        const klines = await fetchKlines(symbol, timeframe, 100);
+        const records = klines.map((k) => ({
+          time: k.openTime,
+          symbol: symbol.toUpperCase(),
+          timeframe,
+          open: k.open,
+          high: k.high,
+          low: k.low,
+          close: k.close,
+          volume: k.volume,
+          trades: k.trades
+        }));
+        await this.store.insertOHLCV(records);
+        this.status.totalRecords += records.length;
+      }
+    };
+  }
+});
+
+// src/cli/commands/collect.ts
+var collect_exports = {};
+__export(collect_exports, {
+  handleCollectStart: () => handleCollectStart,
+  handleCollectStatus: () => handleCollectStatus
+});
+import chalk8 from "chalk";
+async function handleCollectStart(options) {
+  const config2 = getConfig();
+  if (config2.database?.type !== "postgres" || !config2.database.url) {
+    console.log(
+      chalk8.yellow(
+        'Data collection requires PostgreSQL + TimescaleDB.\nSet database.type = "postgres" and database.url in your config.\n\nExample:\n  vizzor config set database.type postgres\n  vizzor config set database.url postgres://user:pass@localhost:5432/vizzor'
+      )
+    );
+    return;
+  }
+  const store = await getStore(config2);
+  const symbols = options.symbols ? options.symbols.split(",").map((s) => s.trim().toUpperCase()) : void 0;
+  const intervalMs = options.interval ? options.interval * 1e3 : void 0;
+  collector = new DataCollector(store, symbols, intervalMs);
+  collector.start();
+  console.log(chalk8.green("Data collector started"));
+  const status = collector.getStatus();
+  console.log(`  Symbols: ${status.symbols.length} pairs`);
+  console.log(`  Timeframes: ${status.timeframes.join(", ")}`);
+  console.log(`  Interval: ${status.intervalMs / 1e3}s`);
+  console.log(chalk8.dim("\nPress Ctrl+C to stop"));
+  process.on("SIGINT", () => {
+    collector?.stop();
+    void store.close();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function handleCollectStatus() {
+  if (!collector) {
+    console.log(chalk8.yellow("No collector running in this process."));
+    console.log(chalk8.dim("Start with: vizzor collect start"));
+    return;
+  }
+  const status = collector.getStatus();
+  console.log(chalk8.bold("Data Collector Status"));
+  console.log(`  Running: ${status.running ? chalk8.green("yes") : chalk8.red("no")}`);
+  console.log(`  Symbols: ${status.symbols.length} pairs`);
+  console.log(`  Timeframes: ${status.timeframes.join(", ")}`);
+  console.log(`  Interval: ${status.intervalMs / 1e3}s`);
+  console.log(`  Last run: ${status.lastRun ? new Date(status.lastRun).toISOString() : "never"}`);
+  console.log(`  Total records: ${status.totalRecords.toLocaleString()}`);
+  console.log(`  Errors: ${status.errors}`);
+}
+var collector;
+var init_collect = __esm({
+  "src/cli/commands/collect.ts"() {
+    "use strict";
+    init_loader();
+    init_store_factory();
+    init_collector();
+    collector = null;
+  }
+});
+
 // src/tui/components/status-bar.tsx
 import React, { useState, useEffect } from "react";
 import { Box, Text, Spacer } from "ink";
@@ -8854,7 +9692,7 @@ function useAIStream() {
 var init_use_ai_stream = __esm({
   "src/tui/hooks/use-ai-stream.ts"() {
     "use strict";
-    init_client();
+    init_client2();
     init_chat();
     init_tools();
     init_context_injector();
@@ -9406,7 +10244,7 @@ var init_commands3 = __esm({
     init_constants();
     init_binance();
     init_agent();
-    init_client();
+    init_client2();
     init_registry2();
     init_types();
   }
@@ -9848,7 +10686,7 @@ var init_app = __esm({
     init_commands3();
     init_loader();
     init_constants();
-    init_client();
+    init_client2();
     init_tool_handler();
     init_tools();
     init_binance();
@@ -9858,12 +10696,12 @@ var init_app = __esm({
 // src/index.ts
 init_loader();
 import { Command } from "commander";
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, resolve as resolve2 } from "path";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var pkg = JSON.parse(readFileSync2(resolve2(__dirname, "..", "package.json"), "utf-8"));
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var pkg = JSON.parse(readFileSync3(resolve3(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command().name("vizzor").description("Crypto chronovisor \u2014 AI-powered on-chain intelligence").version(pkg.version);
 program.hook("preAction", async () => {
   await loadConfig();
@@ -9911,6 +10749,15 @@ botCmd.command("validate").description("Check bot token configuration").action(a
   const { handleBotValidate: handleBotValidate2 } = await Promise.resolve().then(() => (init_bot3(), bot_exports3));
   handleBotValidate2();
 });
+var collectCmd = program.command("collect").description("Data collection pipeline");
+collectCmd.command("start").description("Start background OHLCV data collection (requires PostgreSQL)").option("--symbols <symbols>", "Comma-separated symbols to collect (default: 23 major pairs)").option("--interval <seconds>", "Collection interval in seconds (default: 300)", parseInt).action(async (options) => {
+  const { handleCollectStart: handleCollectStart2 } = await Promise.resolve().then(() => (init_collect(), collect_exports));
+  await handleCollectStart2(options);
+});
+collectCmd.command("status").description("Show data collection status").action(async () => {
+  const { handleCollectStatus: handleCollectStatus2 } = await Promise.resolve().then(() => (init_collect(), collect_exports));
+  handleCollectStatus2();
+});
 var args = process.argv.slice(2);
 if (args.length === 0) {
   await loadConfig();