@leroylabs/cli 0.1.2 → 0.1.4

package/README.md

@@ -6,9 +6,11 @@ The CLI is the command-line surface for Leroy's research-only MCP service.
 
 ```bash
 npm install --global @leroylabs/cli
-leroy connect
 ```
 
+After installation, run `leroy connect` when prompted to connect the CLI to
+your Leroy account.
+
 `leroy connect` validates the endpoint and stores the API key in
 `~/.config/leroy/config.json` with owner-only permissions. The CLI never
 submits orders and never has broker authority.
@@ -19,7 +21,9 @@ From the repository root:
 
 ```bash
 npm run leroy -- help
-npm run leroy -- ask buy ABNB
+npm run leroy -- evaluate ABNB
+npm run leroy -- watch ABNB
+npm run leroy -- evaluate ABNB --demo
 ```
 
 The command reads `LEROY_MCP_URL` and `LEROY_API_KEY` when present. Otherwise,
@@ -28,11 +32,45 @@ Leroy config.
 
 The default endpoint is `https://getleroy.com/api/mcp`.
 
-The CLI supports the authenticated `evaluate_current_setup` MCP tool. Use
-`--json` for agent and shell integrations, or the default terminal format for
-human-readable evidence. A normal request reports current-frame freshness,
-the registered and evaluated strategy counts, exact versus broader Market
-Memory evidence, completed-label counts, and the research-only boundary.
+`evaluate` and `watch` default to the buy case. Use `--side sell` or
+`--side both` when you need to evaluate a different side.
+
+Use `--demo` with `evaluate` or `watch` to render local randomized evidence without
+an API key or network request. Each demo evaluation generates 41 individual
+strategy cells plus varied market context, match strength, and outcomes so the
+interactive UI can be explored outside market hours.
+
+The CLI supports the authenticated `evaluate_current_setup` MCP tool. In an
+interactive terminal, the default `leroy evaluate` view renders the evidence card
+immediately and replaces its loading state with the authenticated result. Use
+`--json` for agent and shell integrations, or `--setup`/`--verbose` when you
+need the deterministic text formatter. A normal request reports current-frame
+freshness, the registered and evaluated strategy counts, exact versus broader
+Market Memory evidence, completed-label counts, and the research-only
+boundary.
+
+Use `leroy watch ABNB` in an interactive terminal to keep the evidence view
+open while the current tape advances. It refreshes once per minute by default,
+which matches the one-minute tape cadence; use `--interval SECONDS` to choose a
+different polling interval. Each refresh is an authenticated evaluation request
+and may count toward the account's lookup allowance.
+
+## Match strength
+
+Leroy selects the strongest available evidence tier and does not pool lower
+tiers into it:
+
+- `5/5`: exact ticker setup
+- `4/5`: same setup on other tickers
+- `3/5`: same 41-sensor state
+- `2/5`: same side with strategy and market context
+- `1/5`: same side baseline
+
+The human-readable output shows `Exact Matches` only for `5/5`. Lower tiers
+show only their own `Comparable Matches` count. Use `--verbose` for the match
+basis, or `--json` for the complete structured response.
+
+The browser reference is available at [getleroy.com/cli](https://getleroy.com/cli).
 
 ## Exit codes
 

package/bin/leroy.mjs

@@ -2,12 +2,28 @@
 
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+import React from "react";
 
 import { parseArgs } from "../src/args.mjs";
 import { LeroyMcpClient } from "../src/client.mjs";
 import { configPath, resolvedConfig, writeConfig } from "../src/config.mjs";
+import { createDemoResponse } from "../src/demo.mjs";
 import { usageError } from "../src/errors.mjs";
 import { formatEvaluation, formatHelp } from "../src/format.mjs";
+import { LiveEvidenceApp, render } from "../src/live-ui.mjs";
+import { ansiForeground, LEROY_COLORS } from "../src/colors.mjs";
+
+const ANSI = {
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+  white: "\u001b[37m",
+  green: ansiForeground(LEROY_COLORS.green),
+  neutral: ansiForeground(LEROY_COLORS.neutral),
+};
+
+function promptStyle(value, tones, enabled) {
+  return enabled ? `${tones.map((tone) => ANSI[tone]).join("")}${value}${ANSI.reset}` : value;
+}
 
 function print(value = "") {
   output.write(`${value}\n`);
@@ -17,9 +33,15 @@ async function connect(options) {
   const config = await resolvedConfig(options);
   let apiKey = config.apiKey;
   if (!apiKey && input.isTTY) {
-    print("Create or activate an MCP key at https://getleroy.com/mcp.");
+    const colorEnabled = output.isTTY && !options.noColor;
+    print();
+    print(`${promptStyle("▲", ["green"], colorEnabled)} ${promptStyle("Connect Leroy", ["bold", "white"], colorEnabled)}`);
+    print();
+    print(`  ${promptStyle("Create or activate an MCP key at", ["neutral"], colorEnabled)}`);
+    print(`  ${promptStyle("https://getleroy.com/mcp", ["green"], colorEnabled)}`);
+    print();
     const readline = createInterface({ input, output });
-    apiKey = (await readline.question("Paste your lr_live_ key: ")).trim();
+    apiKey = (await readline.question(`  ${promptStyle("›", ["green"], colorEnabled)} Paste your ${promptStyle("lr_live_", ["bold", "white"], colorEnabled)} key: `)).trim();
     readline.close();
   }
   if (!apiKey) {
@@ -34,22 +56,76 @@ async function connect(options) {
   return 0;
 }
 
-async function ask(options) {
-  const config = await resolvedConfig(options);
-  if (!config.apiKey) {
-    throw usageError("No API key found. Run `leroy connect` or set LEROY_API_KEY.");
-  }
-  const client = new LeroyMcpClient({ endpoint: config.endpoint, apiKey: config.apiKey });
-  const response = await client.evaluate({
+async function evaluate(options) {
+  const request = {
     symbol: options.symbol,
     side: options.side,
     holding_horizons: options.horizons,
     entry_price: options.entryPrice,
     stop_price: options.stopPrice,
     target_price: options.targetPrice,
-  });
+  };
+  let client;
+  if (options.demo) {
+    client = { evaluate: async () => createDemoResponse(request) };
+  } else {
+    const config = await resolvedConfig(options);
+    if (!config.apiKey) {
+      throw usageError("No API key found. Run `leroy connect` or set LEROY_API_KEY.");
+    }
+    client = new LeroyMcpClient({ endpoint: config.endpoint, apiKey: config.apiKey });
+  }
+  if (input.isTTY && output.isTTY && !options.json && !options.setup && !options.verbose) {
+    const app = render(React.createElement(LiveEvidenceApp, {
+      client,
+      request,
+      colorEnabled: !options.noColor,
+      polling: false,
+    }), { exitOnCtrlC: true });
+    await app.waitUntilExit();
+    return 0;
+  }
+  const response = await client.evaluate(request);
   if (options.json) print(JSON.stringify(response, null, 2));
-  else print(formatEvaluation(response, { colorEnabled: !options.noColor && output.isTTY, horizon: options.horizons.includes(30) ? 30 : options.horizons[options.horizons.length - 1] }));
+  else print(formatEvaluation(response, {
+    colorEnabled: !options.noColor && output.isTTY,
+    horizon: options.horizons.includes(30) ? 30 : options.horizons[options.horizons.length - 1],
+    setup: options.setup,
+    verbose: options.verbose,
+    layout: "grid",
+  }));
+  return 0;
+}
+
+async function watch(options) {
+  if (!input.isTTY || !output.isTTY) {
+    throw usageError("`leroy watch` requires an interactive terminal. Use `leroy evaluate` for one-shot output.");
+  }
+  const request = {
+    symbol: options.symbol,
+    side: options.side,
+    holding_horizons: options.horizons,
+    ...(Number.isFinite(options.entryPrice) ? { entry_price: options.entryPrice } : {}),
+    ...(Number.isFinite(options.stopPrice) ? { stop_price: options.stopPrice } : {}),
+    ...(Number.isFinite(options.targetPrice) ? { target_price: options.targetPrice } : {}),
+  };
+  let client;
+  if (options.demo) {
+    client = { evaluate: async () => createDemoResponse(request) };
+  } else {
+    const config = await resolvedConfig(options);
+    if (!config.apiKey) {
+      throw usageError("No API key found. Run `leroy connect` or set LEROY_API_KEY.");
+    }
+    client = new LeroyMcpClient({ endpoint: config.endpoint, apiKey: config.apiKey });
+  }
+  const app = render(React.createElement(LiveEvidenceApp, {
+    client,
+    request,
+    colorEnabled: !options.noColor,
+    intervalMs: options.intervalSeconds * 1_000,
+  }), { exitOnCtrlC: true });
+  await app.waitUntilExit();
   return 0;
 }
 
@@ -61,7 +137,8 @@ async function main() {
       return 0;
     }
     if (options.command === "connect") return await connect(options);
-    if (options.command === "ask") return await ask(options);
+    if (options.command === "evaluate") return await evaluate(options);
+    if (options.command === "watch") return await watch(options);
     throw usageError("Unknown command: " + options.command + ". Run `leroy help`.");
   } catch (error) {
     console.error(`leroy: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leroylabs/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Command-line access to Leroy market evidence.",
   "type": "module",
   "files": [
@@ -19,6 +19,11 @@
   "bin": {
     "leroy": "bin/leroy.mjs"
   },
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "ink": "^7.1.1",
+    "react": "^19.2.8"
+  },
   "engines": {
     "node": ">=22"
   }

package/src/args.mjs

@@ -18,11 +18,16 @@ export function parseArgs(argv) {
     apiKey: null,
     json: false,
     noColor: false,
+    setup: false,
+    verbose: false,
+    demo: false,
     entryPrice: null,
     stopPrice: null,
     targetPrice: null,
+    intervalSeconds: 60,
   };
   const positional = [];
+  let sideFlagProvided = false;
   for (let index = 0; index < rest.length; index += 1) {
     const value = rest[index];
     if (!value.startsWith("--")) {
@@ -30,28 +35,63 @@ export function parseArgs(argv) {
       continue;
     }
     const [flag, inline] = value.split("=", 2);
+    if (flag === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (flag === "--no-color") {
+      options.noColor = true;
+      continue;
+    }
+    if (flag === "--setup") {
+      options.setup = true;
+      continue;
+    }
+    if (flag === "--verbose") {
+      options.verbose = true;
+      continue;
+    }
+    if (flag === "--demo") {
+      options.demo = true;
+      continue;
+    }
+    if (flag === "--help" || flag === "-h") {
+      options.command = "help";
+      continue;
+    }
     const next = inline ?? rest[++index];
-    if (flag === "--side") options.side = next;
+    if (flag === "--side") {
+      options.side = next;
+      sideFlagProvided = true;
+    }
     else if (flag === "--horizon") options.horizons = [Number(next)];
     else if (flag === "--endpoint") options.endpoint = next;
     else if (flag === "--api-key") options.apiKey = next;
     else if (flag === "--entry-price") options.entryPrice = numberValue(next, flag);
     else if (flag === "--stop-price") options.stopPrice = numberValue(next, flag);
     else if (flag === "--target-price") options.targetPrice = numberValue(next, flag);
-    else if (flag === "--json") options.json = true;
-    else if (flag === "--no-color") options.noColor = true;
-    else if (flag === "--help" || flag === "-h") options.command = "help";
+    else if (flag === "--interval") options.intervalSeconds = numberValue(next, flag);
     else throw usageError(`Unknown option: ${flag}`);
   }
-  if (command === "ask" && ["buy", "sell", "both"].includes(positional[0]?.toLowerCase())) {
-    if (options.side === "buy") options.side = positional[0].toLowerCase();
+  if (["evaluate", "watch"].includes(command) && ["buy", "sell", "both"].includes(positional[0]?.toLowerCase())) {
+    const positionalSide = positional[0].toLowerCase();
+    if (sideFlagProvided && options.side !== positionalSide) {
+      throw usageError("Specify the side once, using either a positional value or --side.");
+    }
+    if (!sideFlagProvided) options.side = positionalSide;
     positional.shift();
   }
   options.symbol = positional[0] ? positional[0].toUpperCase() : null;
-  if (options.command === "ask") {
-    if (!options.symbol || !/^[A-Z][A-Z0-9.-]{0,11}$/.test(options.symbol)) throw usageError("Usage: leroy ask buy|sell|both SYMBOL");
+  if (["evaluate", "watch"].includes(options.command)) {
+    if (!options.symbol || !/^[A-Z][A-Z0-9.-]{0,11}$/.test(options.symbol)) {
+      throw usageError(`Usage: leroy ${options.command} SYMBOL [--side buy|sell|both]`);
+    }
     if (!["buy", "sell", "both"].includes(options.side)) throw usageError("--side must be buy, sell, or both.");
     if (!options.horizons.every((horizon) => DEFAULT_HORIZONS.includes(horizon))) throw usageError("--horizon must be 5, 15, 30, or 60.");
+    if (options.command === "watch" && options.json) throw usageError("`leroy watch` cannot be combined with --json.");
+  }
+  if (options.demo && !["evaluate", "watch"].includes(options.command)) {
+    throw usageError("`--demo` can only be used with `leroy evaluate` or `leroy watch`.");
   }
   return options;
 }

package/src/client.mjs

@@ -39,6 +39,7 @@ export class LeroyMcpClient {
     this.fetchImpl = fetchImpl;
     this.sessionId = null;
     this.requestId = 0;
+    this.initialized = false;
   }
 
   async request(method, params = {}, { notification = false } = {}) {
@@ -70,31 +71,39 @@ export class LeroyMcpClient {
   }
 
   async initialize() {
+    if (this.initialized) return null;
     const envelope = await this.request("initialize", {
       protocolVersion: MCP_PROTOCOL_VERSION,
       capabilities: {},
       clientInfo: { name: "leroy-cli", version: "0.1.0" },
     });
     await this.request("notifications/initialized", {}, { notification: true }).catch(() => undefined);
+    this.initialized = true;
     return envelope;
   }
 
   async evaluate({ symbol, side, holding_horizons = [5, 15, 30, 60], entry_price, stop_price, target_price }) {
     await this.initialize();
-    const envelope = await this.request("tools/call", {
-      name: "evaluate_current_setup",
-      arguments: {
-        symbol: symbol.trim().toUpperCase(),
-        side,
-        holding_horizons,
-        ...(Number.isFinite(entry_price) ? { entry_price } : {}),
-        ...(Number.isFinite(stop_price) ? { stop_price } : {}),
-        ...(Number.isFinite(target_price) ? { target_price } : {}),
-        client_request_id: `leroy-cli-${randomUUID()}`,
-      },
-    });
-    const content = structuredContent(envelope);
-    if (!content) throw new Error("Leroy returned an MCP response without structured evaluation data.");
-    return content;
+    try {
+      const envelope = await this.request("tools/call", {
+        name: "evaluate_current_setup",
+        arguments: {
+          symbol: symbol.trim().toUpperCase(),
+          side,
+          holding_horizons,
+          ...(Number.isFinite(entry_price) ? { entry_price } : {}),
+          ...(Number.isFinite(stop_price) ? { stop_price } : {}),
+          ...(Number.isFinite(target_price) ? { target_price } : {}),
+          client_request_id: `leroy-cli-${randomUUID()}`,
+        },
+      });
+      const content = structuredContent(envelope);
+      if (!content) throw new Error("Leroy returned an MCP response without structured evaluation data.");
+      return content;
+    } catch (error) {
+      this.initialized = false;
+      this.sessionId = null;
+      throw error;
+    }
   }
 }

package/src/colors.mjs

@@ -0,0 +1,14 @@
+export const LEROY_COLORS = Object.freeze({
+  green: "#00D41B",
+  inactive: "#29332B",
+  neutral: "#8F9591",
+  red: "#F2562F",
+});
+
+export function ansiForeground(hex) {
+  const value = hex.replace(/^#/, "");
+  const red = Number.parseInt(value.slice(0, 2), 16);
+  const green = Number.parseInt(value.slice(2, 4), 16);
+  const blue = Number.parseInt(value.slice(4, 6), 16);
+  return `\u001b[38;2;${red};${green};${blue}m`;
+}

package/src/demo.mjs

@@ -0,0 +1,144 @@
+const DEMO_PRICE_BASES = {
+  ABNB: 183,
+  AAPL: 229,
+  AMZN: 231,
+  GOOG: 214,
+  META: 736,
+  MSFT: 505,
+  NVDA: 181,
+  TSLA: 339,
+};
+
+const MATCH_TIERS = [
+  null,
+  { match_kind: "side", scope: "all_market_memory_observations" },
+  { match_kind: "forward_overlay_context", scope: "forward_overlay_current_context" },
+  { match_kind: "strategy", scope: "exact_41_sensor_state" },
+  { match_kind: "cross_ticker_context", scope: "cross_ticker_exact_state" },
+  { match_kind: "context", scope: "same_ticker_exact" },
+];
+
+function unit(rng) {
+  const value = Number(rng());
+  return Number.isFinite(value) ? Math.min(0.999999, Math.max(0, value)) : 0;
+}
+
+function randomInt(rng, minimum, maximum) {
+  return minimum + Math.floor(unit(rng) * (maximum - minimum + 1));
+}
+
+function randomBetween(rng, minimum, maximum, digits = 2) {
+  const value = minimum + unit(rng) * (maximum - minimum);
+  return Number(value.toFixed(digits));
+}
+
+function shuffled(values, rng) {
+  const result = [...values];
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swapIndex = randomInt(rng, 0, index);
+    [result[index], result[swapIndex]] = [result[swapIndex], result[index]];
+  }
+  return result;
+}
+
+function strategyStates(rng) {
+  const buy = randomInt(rng, 0, 18);
+  const sell = randomInt(rng, 0, Math.min(18, 41 - buy));
+  const neutral = 41 - buy - sell;
+  return shuffled([
+    ...Array.from({ length: buy }, () => "buy"),
+    ...Array.from({ length: neutral }, () => "neutral"),
+    ...Array.from({ length: sell }, () => "sell"),
+  ], rng);
+}
+
+function outcomeFor(rng, horizon, score) {
+  const direction = unit(rng) > 0.42 ? 1 : -1;
+  const magnitude = horizon / 60 * randomBetween(rng, 0.25, 1.35);
+  const mean = Number((direction * magnitude).toFixed(2));
+  const winRate = randomBetween(rng, direction > 0 ? 0.48 : 0.34, direction > 0 ? 0.72 : 0.56, 2);
+  const lift = Number((direction * randomBetween(rng, 1.5, 18)).toFixed(2));
+  return {
+    sample_size: score > 0 ? randomInt(rng, 40, 980000000) : 0,
+    mean_return_pct: mean,
+    win_rate: winRate,
+    lift_vs_baseline_bps: lift,
+  };
+}
+
+function matchFor(rng, score, outcomes) {
+  const tier = MATCH_TIERS[score];
+  if (!tier) return null;
+  const rowCount = score === 5
+    ? randomInt(rng, 250000000, 980000000)
+    : score === 4
+      ? randomInt(rng, 100000, 9000000)
+      : score === 3
+        ? randomInt(rng, 5000, 250000)
+        : score === 2
+          ? randomInt(rng, 1000, 50000)
+          : randomInt(rng, 250, 5000000000);
+  return {
+    ...tier,
+    row_count: rowCount,
+    first_session: "2010-03-31",
+    last_session: "2026-08-24",
+    outcomes,
+  };
+}
+
+export function createDemoResponse(request = {}, rng = Math.random) {
+  const symbol = typeof request.symbol === "string" ? request.symbol.toUpperCase() : "ABNB";
+  const side = ["buy", "sell", "both"].includes(request.side) ? request.side : "buy";
+  const score = randomInt(rng, 0, 5);
+  const states = strategyStates(rng);
+  const sourceTime = new Date(Date.now() - randomInt(rng, 0, 45) * 60_000).toISOString();
+  const basePrice = DEMO_PRICE_BASES[symbol] ?? randomBetween(rng, 35, 480);
+  const last = Number((basePrice + randomBetween(rng, -4.5, 4.5)).toFixed(2));
+  const outcomes = score > 0
+    ? Object.fromEntries([15, 30, 60].map((horizon) => [String(horizon), outcomeFor(rng, horizon, score)]))
+    : {};
+  const match = matchFor(rng, score, outcomes);
+  const marketContext = {
+    session_return_pct: randomBetween(rng, -4.2, 4.2),
+    vwap_distance_pct: randomBetween(rng, -2.4, 2.4),
+    atr_pct: randomBetween(rng, 0.05, 2.6),
+    volume_ratio: randomBetween(rng, 0.35, 2.1),
+  };
+  const benchmarkContext = {
+    session_return_pct: randomBetween(rng, -1.8, 1.8),
+    vwap_distance_pct: randomBetween(rng, -0.9, 0.9),
+    atr_pct: randomBetween(rng, 0.08, 1.4),
+    volume_ratio: randomBetween(rng, 0.55, 1.65),
+  };
+
+  return {
+    status: "evaluated",
+    request: { symbol, side, holding_horizons: request.holding_horizons ?? [5, 15, 30, 60] },
+    current_market_frame: {
+      symbol,
+      source_time: sourceTime,
+      market_session_status: unit(rng) > 0.5 ? "open" : "closed",
+      quote: { last },
+      market_context: marketContext,
+      benchmark: { symbol: "SPY", market_context: benchmarkContext },
+    },
+    strategy_states: states.map((state) => ({ state })),
+    historical_evidence: score > 0
+      ? [15, 30, 60].map((horizon_minutes) => ({
+        horizon_minutes,
+        availability: "available",
+        ...outcomes[String(horizon_minutes)],
+      }))
+      : [],
+    market_memory: {
+      status: score > 0 ? "historical_match" : "insufficient_context",
+      coverage: {
+        date_start: "2010-03-31",
+        date_end: "2026-08-24",
+        strategy_evaluations: 105447109561,
+      },
+      matches: match ? [{ side, matches: [match] }] : [],
+    },
+  };
+}