@vizzor/cli 0.6.0 → 0.8.0

package/dist/index.js

@@ -59,6 +59,17 @@ var init_schema = __esm({
         sidecarUrl: "http://localhost:8000",
         fallbackToRules: true
       })),
+      api: z.object({
+        port: z.number().default(3e3),
+        host: z.string().default("0.0.0.0"),
+        enableAuth: z.boolean().default(false),
+        corsOrigin: z.string().default("*")
+      }).default(() => ({
+        port: 3e3,
+        host: "0.0.0.0",
+        enableAuth: false,
+        corsOrigin: "*"
+      })),
       discordToken: z.string().optional(),
       discordGuildId: z.string().optional(),
       telegramToken: z.string().optional()
@@ -656,12 +667,12 @@ var init_adapter = __esm({
           toBlock: options?.toBlock,
           args: options?.args
         });
-        return logs.map((log3) => ({
-          eventName: log3.eventName ?? eventName,
-          blockNumber: log3.blockNumber ?? 0n,
-          transactionHash: log3.transactionHash ?? "0x",
-          args: log3.args ?? {},
-          logIndex: log3.logIndex ?? 0
+        return logs.map((log4) => ({
+          eventName: log4.eventName ?? eventName,
+          blockNumber: log4.blockNumber ?? 0n,
+          transactionHash: log4.transactionHash ?? "0x",
+          args: log4.args ?? {},
+          logIndex: log4.logIndex ?? 0
         }));
       }
       // ── Tokens ──────────────────────────────────────────────────────────────
@@ -5962,6 +5973,106 @@ var init_trend_following = __esm({
   }
 });
 
+// src/core/agent/strategies/ml-adaptive.ts
+function evaluateWithRules(signals) {
+  const reasoning = [];
+  let score = 0;
+  if (signals.rsi !== null) {
+    if (signals.rsi < 25) {
+      score += 35;
+      reasoning.push(`RSI deeply oversold (${signals.rsi.toFixed(0)})`);
+    } else if (signals.rsi < 35) {
+      score += 20;
+      reasoning.push(`RSI oversold zone (${signals.rsi.toFixed(0)})`);
+    } else if (signals.rsi > 75) {
+      score -= 35;
+      reasoning.push(`RSI deeply overbought (${signals.rsi.toFixed(0)})`);
+    } else if (signals.rsi > 65) {
+      score -= 20;
+      reasoning.push(`RSI overbought zone (${signals.rsi.toFixed(0)})`);
+    }
+  }
+  if (signals.macdHistogram !== null) {
+    if (signals.macdHistogram > 0) {
+      score += 15;
+      reasoning.push("MACD bullish momentum");
+    } else {
+      score -= 15;
+      reasoning.push("MACD bearish momentum");
+    }
+  }
+  if (signals.ema12 !== null && signals.ema26 !== null) {
+    const crossPct = signals.ema26 !== 0 ? (signals.ema12 - signals.ema26) / signals.ema26 * 100 : 0;
+    if (crossPct > 0.5) {
+      score += 20;
+      reasoning.push(`Golden cross (EMA12 > EMA26 by ${crossPct.toFixed(2)}%)`);
+    } else if (crossPct < -0.5) {
+      score -= 20;
+      reasoning.push(`Death cross (EMA12 < EMA26 by ${Math.abs(crossPct).toFixed(2)}%)`);
+    }
+  }
+  if (signals.bollingerPercentB !== null) {
+    if (signals.bollingerPercentB < 0.1) {
+      score += 15;
+      reasoning.push("Price at lower Bollinger Band \u2014 potential bounce");
+    } else if (signals.bollingerPercentB > 0.9) {
+      score -= 15;
+      reasoning.push("Price at upper Bollinger Band \u2014 potential resistance");
+    }
+  }
+  if (signals.fundingRate !== null) {
+    if (signals.fundingRate > 5e-4) {
+      score -= 10;
+      reasoning.push("High funding rate \u2014 overleveraged longs");
+    } else if (signals.fundingRate < -3e-4) {
+      score += 10;
+      reasoning.push("Negative funding \u2014 capitulation signal");
+    }
+  }
+  if (signals.fearGreed !== null) {
+    if (signals.fearGreed < 20) {
+      score += 10;
+      reasoning.push("Extreme fear \u2014 contrarian bullish");
+    } else if (signals.fearGreed > 80) {
+      score -= 10;
+      reasoning.push("Extreme greed \u2014 contrarian bearish");
+    }
+  }
+  if (signals.priceChange24h !== null) {
+    if (signals.priceChange24h > 5) {
+      score += 10;
+    } else if (signals.priceChange24h < -5) {
+      score -= 10;
+    }
+  }
+  const confidence = Math.min(95, Math.abs(score));
+  if (score > 20) {
+    return { action: "buy", confidence, reasoning };
+  } else if (score < -20) {
+    return { action: "sell", confidence, reasoning };
+  }
+  return {
+    action: "hold",
+    confidence: Math.max(30, 50 - Math.abs(score)),
+    reasoning: [...reasoning, "Mixed signals \u2014 holding"]
+  };
+}
+var mlAdaptiveStrategy;
+var init_ml_adaptive = __esm({
+  "src/core/agent/strategies/ml-adaptive.ts"() {
+    "use strict";
+    init_client();
+    init_feature_engineer();
+    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.",
+      evaluate(signals) {
+        return evaluateWithRules(signals);
+      }
+    };
+  }
+});
+
 // src/core/agent/manager.ts
 import { randomUUID } from "crypto";
 function getStrategy(name) {
@@ -6132,9 +6243,11 @@ var init_manager = __esm({
     init_engine();
     init_momentum();
     init_trend_following();
+    init_ml_adaptive();
     STRATEGIES = {
       momentum: momentumStrategy,
-      "trend-following": trendFollowingStrategy
+      "trend-following": trendFollowingStrategy,
+      "ml-adaptive": mlAdaptiveStrategy
     };
     engines = /* @__PURE__ */ new Map();
   }
@@ -8952,6 +9065,481 @@ var init_collect = __esm({
   }
 });
 
+// src/api/routes/v1/market.ts
+async function registerMarketRoutes(server) {
+  server.get("/price/:symbol", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get live price and market data for a symbol",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_market_data", { symbol });
+    }
+  });
+  server.get("/trending", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get trending tokens from DEX and CoinGecko"
+    },
+    handler: async () => {
+      return handleTool("get_trending", {});
+    }
+  });
+  server.get("/fear-greed", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get Crypto Fear & Greed Index with history"
+    },
+    handler: async () => {
+      return handleTool("get_fear_greed", {});
+    }
+  });
+  server.get("/news", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get latest crypto news with sentiment",
+      querystring: {
+        type: "object",
+        properties: { symbol: { type: "string" } }
+      }
+    },
+    handler: async (request) => {
+      const { symbol } = request.query;
+      return handleTool("get_crypto_news", { symbol });
+    }
+  });
+  server.get("/dex/search", {
+    schema: {
+      tags: ["Market"],
+      summary: "Search tokens on decentralized exchanges",
+      querystring: {
+        type: "object",
+        properties: { q: { type: "string" } },
+        required: ["q"]
+      }
+    },
+    handler: async (request) => {
+      const { q } = request.query;
+      return handleTool("search_token_dex", { query: q });
+    }
+  });
+  server.get("/derivatives/:symbol", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get derivatives data (funding rate, open interest)",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_derivatives_data", { symbol });
+    }
+  });
+}
+var init_market3 = __esm({
+  "src/api/routes/v1/market.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/routes/v1/analysis.ts
+async function registerAnalysisRoutes(server) {
+  server.get("/technical/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Run technical analysis on a symbol",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] },
+      querystring: {
+        type: "object",
+        properties: { timeframe: { type: "string", default: "4h" } }
+      }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      const { timeframe } = request.query;
+      return handleTool("get_technical_analysis", { symbol, timeframe });
+    }
+  });
+  server.get("/prediction/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Generate multi-signal composite prediction",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_prediction", { symbol });
+    }
+  });
+  server.get("/ml/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Get ML-enhanced prediction from sidecar models",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_ml_prediction", { symbol });
+    }
+  });
+  server.get("/raises/recent", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Get recent crypto fundraising rounds",
+      querystring: {
+        type: "object",
+        properties: {
+          category: { type: "string" },
+          chain: { type: "string" }
+        }
+      }
+    },
+    handler: async (request) => {
+      const { category, chain } = request.query;
+      return handleTool("get_raises", { category, chain });
+    }
+  });
+}
+var init_analysis = __esm({
+  "src/api/routes/v1/analysis.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/routes/v1/security.ts
+async function registerSecurityRoutes(server) {
+  server.post("/token", {
+    schema: {
+      tags: ["Security"],
+      summary: "Check token security via GoPlus",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("get_token_security", { address, chain });
+    }
+  });
+  server.post("/rug-check", {
+    schema: {
+      tags: ["Security"],
+      summary: "Check token for rug pull indicators",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("check_rug_indicators", { address, chain });
+    }
+  });
+  server.post("/wallet", {
+    schema: {
+      tags: ["Security"],
+      summary: "Analyze a wallet address",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("analyze_wallet", { address, chain });
+    }
+  });
+}
+var init_security = __esm({
+  "src/api/routes/v1/security.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/auth/keys.ts
+import { randomBytes, scryptSync } from "crypto";
+function hashApiKey(key) {
+  return scryptSync(key, API_KEY_SALT, 64).toString("hex");
+}
+function ensureKeysTable() {
+  getDb().exec(`
+    CREATE TABLE IF NOT EXISTS api_keys (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      key_hash TEXT NOT NULL UNIQUE,
+      key_prefix TEXT NOT NULL,
+      rate_limit INTEGER NOT NULL DEFAULT 100,
+      created_at INTEGER NOT NULL,
+      revoked_at INTEGER
+    )
+  `);
+}
+function createApiKey(label) {
+  ensureKeysTable();
+  const rawKey = `vzr_${randomBytes(32).toString("hex")}`;
+  const keyHash = hashApiKey(rawKey);
+  const keyPrefix = rawKey.slice(0, 12) + "...";
+  const id = randomBytes(16).toString("hex");
+  const now = Date.now();
+  getDb().prepare(
+    `INSERT INTO api_keys (id, label, key_hash, key_prefix, rate_limit, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(id, label, keyHash, keyPrefix, 100, now);
+  return {
+    key: rawKey,
+    record: { id, label, keyPrefix, rateLimit: 100, createdAt: now, revokedAt: null }
+  };
+}
+function listApiKeys() {
+  ensureKeysTable();
+  const rows = getDb().prepare("SELECT * FROM api_keys WHERE revoked_at IS NULL ORDER BY created_at DESC").all();
+  return rows.map((r) => ({
+    id: r.id,
+    label: r.label,
+    keyPrefix: r.key_prefix,
+    rateLimit: r.rate_limit,
+    createdAt: r.created_at,
+    revokedAt: r.revoked_at
+  }));
+}
+function revokeApiKey(id) {
+  ensureKeysTable();
+  const result = getDb().prepare("UPDATE api_keys SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL").run(Date.now(), id);
+  return result.changes > 0;
+}
+var API_KEY_SALT;
+var init_keys2 = __esm({
+  "src/api/auth/keys.ts"() {
+    "use strict";
+    init_cache();
+    API_KEY_SALT = "vizzor-api-key-v1";
+  }
+});
+
+// src/api/auth/middleware.ts
+async function authMiddleware(request, reply) {
+  if (PUBLIC_PATHS.some((p) => request.url === p) || request.url.startsWith("/docs/")) {
+    return;
+  }
+  const apiKey = request.headers["x-api-key"];
+  if (!apiKey) {
+    return reply.status(401).send({
+      error: "Unauthorized",
+      message: "Missing X-API-Key header"
+    });
+  }
+  const keyHash = hashApiKey(apiKey);
+  const valid = await validateKey2(keyHash);
+  if (!valid) {
+    return reply.status(403).send({
+      error: "Forbidden",
+      message: "Invalid API key"
+    });
+  }
+}
+async function validateKey2(keyHash) {
+  const store = getStoreInstance();
+  if (!store) return false;
+  const cached = await store.getCached(`apikey:${keyHash}`);
+  if (cached !== null) return cached.valid;
+  return true;
+}
+var PUBLIC_PATHS;
+var init_middleware = __esm({
+  "src/api/auth/middleware.ts"() {
+    "use strict";
+    init_keys2();
+    init_store_factory();
+    PUBLIC_PATHS = ["/health", "/docs", "/docs/"];
+  }
+});
+
+// src/api/middleware/error-handler.ts
+function errorHandler(error, _request, reply) {
+  if (error.statusCode === 429) {
+    void reply.status(429).send({
+      error: "Too Many Requests",
+      message: "Rate limit exceeded. Try again later."
+    });
+    return;
+  }
+  const status = error.statusCode ?? 500;
+  void reply.status(status).send({
+    error: error.name ?? "InternalError",
+    message: status >= 500 ? "Internal server error" : error.message
+  });
+}
+var init_error_handler = __esm({
+  "src/api/middleware/error-handler.ts"() {
+    "use strict";
+  }
+});
+
+// src/api/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startApiServer: () => startApiServer
+});
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import rateLimit from "@fastify/rate-limit";
+import swagger from "@fastify/swagger";
+import swaggerUi from "@fastify/swagger-ui";
+async function startApiServer(options) {
+  const server = Fastify({ logger: false });
+  await server.register(cors, { origin: true });
+  await server.register(rateLimit, {
+    max: 100,
+    timeWindow: "1 minute"
+  });
+  await server.register(swagger, {
+    openapi: {
+      info: {
+        title: "Vizzor API",
+        description: "AI-powered crypto intelligence REST API",
+        version: "0.7.0"
+      },
+      servers: [{ url: `http://${options.host}:${options.port}` }],
+      components: {
+        securitySchemes: {
+          apiKey: {
+            type: "apiKey",
+            name: "X-API-Key",
+            in: "header"
+          }
+        }
+      }
+    }
+  });
+  await server.register(swaggerUi, {
+    routePrefix: "/docs"
+  });
+  if (options.enableAuth) {
+    server.addHook("onRequest", authMiddleware);
+  }
+  server.setErrorHandler(errorHandler);
+  server.get("/health", async () => ({
+    status: "ok",
+    version: "0.7.0",
+    uptime: process.uptime(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  await server.register(registerMarketRoutes, { prefix: "/v1/market" });
+  await server.register(registerAnalysisRoutes, { prefix: "/v1/analysis" });
+  await server.register(registerSecurityRoutes, { prefix: "/v1/security" });
+  await server.listen({ port: options.port, host: options.host });
+  log3.info(`Vizzor API listening on ${options.host}:${options.port}`);
+  log3.info(`OpenAPI docs at http://${options.host}:${options.port}/docs`);
+}
+var log3;
+var init_server = __esm({
+  "src/api/server.ts"() {
+    "use strict";
+    init_logger();
+    init_market3();
+    init_analysis();
+    init_security();
+    init_middleware();
+    init_error_handler();
+    log3 = createLogger("api");
+  }
+});
+
+// src/cli/commands/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  handleServe: () => handleServe
+});
+import chalk9 from "chalk";
+async function handleServe(options) {
+  console.log(chalk9.bold("Starting Vizzor REST API..."));
+  const { startApiServer: startApiServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startApiServer2({
+    port: options.port,
+    host: options.host,
+    enableAuth: options.auth
+  });
+  console.log(chalk9.green(`API running on http://${options.host}:${options.port}`));
+  console.log(chalk9.dim(`Docs: http://${options.host}:${options.port}/docs`));
+  console.log(chalk9.dim("\nPress Ctrl+C to stop"));
+  process.on("SIGINT", () => {
+    console.log(chalk9.yellow("\nShutting down..."));
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+var init_serve = __esm({
+  "src/cli/commands/serve.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/api.ts
+var api_exports = {};
+__export(api_exports, {
+  handleApiKeyCreate: () => handleApiKeyCreate,
+  handleApiKeyList: () => handleApiKeyList,
+  handleApiKeyRevoke: () => handleApiKeyRevoke
+});
+import chalk10 from "chalk";
+function handleApiKeyCreate(label) {
+  const { key, record } = createApiKey(label || "default");
+  console.log(chalk10.green("API key created successfully!"));
+  process.stdout.write(chalk10.bold(`
+  Key: ${key}
+
+`));
+  console.log(chalk10.yellow("  Save this key \u2014 it will not be shown again."));
+  console.log(`  Label: ${record.label}`);
+  console.log(`  ID: ${record.id}`);
+}
+function handleApiKeyList() {
+  const keys = listApiKeys();
+  if (keys.length === 0) {
+    console.log(chalk10.dim("No API keys found. Create one with: vizzor api key create [label]"));
+    return;
+  }
+  console.log(chalk10.bold("Active API Keys\n"));
+  for (const k of keys) {
+    console.log(`  ${chalk10.cyan(k.keyPrefix)}  ${k.label}  (${k.id.slice(0, 8)})`);
+    console.log(`    Rate limit: ${k.rateLimit} req/min`);
+    console.log(`    Created: ${new Date(k.createdAt).toISOString()}
+`);
+  }
+}
+function handleApiKeyRevoke(id) {
+  const revoked = revokeApiKey(id);
+  if (revoked) {
+    console.log(chalk10.green(`API key ${id} revoked.`));
+  } else {
+    console.log(chalk10.red(`No active key found with ID: ${id}`));
+  }
+}
+var init_api = __esm({
+  "src/cli/commands/api.ts"() {
+    "use strict";
+    init_keys2();
+  }
+});
+
 // src/tui/components/status-bar.tsx
 import React, { useState, useEffect } from "react";
 import { Box, Text, Spacer } from "ink";
@@ -10127,8 +10715,8 @@ async function handleConfig(args2) {
     }
     const isSensitive = key.toLowerCase().includes("key") || key.toLowerCase().includes("token");
     if (isSensitive) {
-      const { validateKey: validateKey2 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
-      const error = validateKey2(key, value);
+      const { validateKey: validateKey3 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
+      const error = validateKey3(key, value);
       if (error && !error.startsWith("Warning:")) {
         return { blocks: [], text: `Rejected: ${error}` };
       }
@@ -10758,6 +11346,24 @@ 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) => {
+  const { handleServe: handleServe2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
+  await handleServe2(options);
+});
+var apiCmd = program.command("api").description("API management");
+var apiKeyCmd = apiCmd.command("key").description("API key management");
+apiKeyCmd.command("create [label]").description("Generate a new API key").action(async (label) => {
+  const { handleApiKeyCreate: handleApiKeyCreate2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyCreate2(label);
+});
+apiKeyCmd.command("list").description("List active API keys").action(async () => {
+  const { handleApiKeyList: handleApiKeyList2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyList2();
+});
+apiKeyCmd.command("revoke <id>").description("Revoke an API key").action(async (id) => {
+  const { handleApiKeyRevoke: handleApiKeyRevoke2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyRevoke2(id);
+});
 var args = process.argv.slice(2);
 if (args.length === 0) {
   await loadConfig();