@vizzor/cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -46,6 +46,10 @@ 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" })),
       discordToken: z.string().optional(),
       discordGuildId: z.string().optional(),
       telegramToken: z.string().optional()
@@ -643,12 +647,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((log2) => ({
+          eventName: log2.eventName ?? eventName,
+          blockNumber: log2.blockNumber ?? 0n,
+          transactionHash: log2.transactionHash ?? "0x",
+          args: log2.args ?? {},
+          logIndex: log2.logIndex ?? 0
         }));
       }
       // ── Tokens ──────────────────────────────────────────────────────────────
@@ -2561,7 +2565,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}`));
@@ -5514,6 +5528,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"() {
@@ -8048,40 +8082,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 +8126,613 @@ var init_bot3 = __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;
+}
+var instance;
+var init_store_factory = __esm({
+  "src/data/store-factory.ts"() {
+    "use strict";
+    init_sqlite_store();
+    instance = null;
+  }
+});
+
+// src/data/collector.ts
+var log, MAJOR_SYMBOLS, TIMEFRAMES, COLLECTION_INTERVAL_MS, DataCollector;
+var init_collector = __esm({
+  "src/data/collector.ts"() {
+    "use strict";
+    init_binance();
+    init_logger();
+    log = 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) {
+          log.warn("Collector already running");
+          return;
+        }
+        log.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;
+        log.info("Data collector stopped");
+      }
+      async collectAll() {
+        log.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++;
+              log.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);
+        log.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";
@@ -9858,12 +10477,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 +10530,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();