moshcode 0.26.0 → 0.28.0

package/src/advisor.mjs

@@ -1,4 +1,4 @@
-// `moshcode ticker` — equity research from advis0r.com, in the pit.
+// `moshcode stocks` — equity research from advis0r.com, in the pit.
 //
 // Same split as src/trade.mjs: argument translation is pure and testable, the
 // network call is injectable, and rendering is a function of the decoded JSON.
@@ -18,7 +18,7 @@ export function advisorBase(env = process.env) {
   return (raw || DEFAULT_ADVISOR_URL).replace(/\/+$/, "");
 }
 
-const USAGE = `usage: moshcode ticker <symbol|verb> [args…]
+const USAGE = `usage: moshcode stocks <symbol|verb> [args…]
 
   <symbol>                       the stored research report for one ticker
   report <symbol>                same thing, when a symbol looks like a verb
@@ -40,17 +40,17 @@ const USAGE = `usage: moshcode ticker <symbol|verb> [args…]
 Research aid, not advice. Every route is public, read-only, and served from
 stored snapshots — see the generated-at stamp printed with each report.`;
 
-export function tickerUsage() {
+export function stocksUsage() {
   return USAGE;
 }
 
-/** Verb names, in help order. cli-schema's TICKER_VERBS must match (drift test). */
-export const TICKER_VERB_NAMES = [
+/** Verb names, in help order. cli-schema's STOCKS_VERBS must match (drift test). */
+export const STOCKS_VERB_NAMES = [
   "report", "signals", "search", "lookup", "reports", "discover", "tickers", "stats", "open",
 ];
 
-// Aliases exist because muscle memory differs: `/ticker news AAPL` and
-// `/ticker quotes AAPL` should not be errors when the intent is obvious.
+// Aliases exist because muscle memory differs: `/stocks news AAPL` and
+// `/stocks quotes AAPL` should not be errors when the intent is obvious.
 const VERB_ALIASES = {
   signal: "signals", news: "signals",
   find: "search", grep: "search", q: "search",
@@ -66,7 +66,7 @@ const VERB_ALIASES = {
 /** Resolve a first argument to a canonical verb, or null when it is a symbol. */
 export function resolveVerb(word) {
   const key = String(word ?? "").toLowerCase();
-  if (TICKER_VERB_NAMES.includes(key)) return key;
+  if (STOCKS_VERB_NAMES.includes(key)) return key;
   return VERB_ALIASES[key] ?? null;
 }
 
@@ -114,13 +114,13 @@ function positiveInt(value, { max }) {
 const SORTS = ["recent", "score", "ticker"];
 
 /**
- * Translate `ticker` arguments into a request the caller can execute.
+ * Translate `stocks` arguments into a request the caller can execute.
  *
  * Returns one of `{ usage }`, `{ error }`, or
  * `{ verb, path, query, json, open? }` — never performs IO, so the whole
  * argument surface is testable without a network.
  */
-export function tickerArgs(input = []) {
+export function stocksArgs(input = []) {
   const args = input.map(String);
   const jsonFlag = takeFlag(args, "--json", { boolean: true });
   let rest = jsonFlag.rest;
@@ -131,26 +131,26 @@ export function tickerArgs(input = []) {
   const horizonFlag = takeFlag(rest, "--horizon"); rest = horizonFlag.rest;
   const providerFlag = takeFlag(rest, "--provider"); rest = providerFlag.rest;
 
-  if (limitFlag.missing) return { error: "ticker --limit requires a positive number" };
-  if (sortFlag.missing) return { error: `ticker --sort requires one of ${SORTS.join(", ")}` };
-  if (horizonFlag.missing) return { error: "ticker --horizon requires 1 or 2" };
-  if (providerFlag.missing) return { error: "ticker --provider requires a name" };
+  if (limitFlag.missing) return { error: "stocks --limit requires a positive number" };
+  if (sortFlag.missing) return { error: `stocks --sort requires one of ${SORTS.join(", ")}` };
+  if (horizonFlag.missing) return { error: "stocks --horizon requires 1 or 2" };
+  if (providerFlag.missing) return { error: "stocks --provider requires a name" };
 
   // A limit above the server's own cap is silently clamped there; clamping here
   // too keeps `--limit 9999` from reading like a promise the API never made.
   const limit = limitFlag.value == null ? null : positiveInt(limitFlag.value, { max: 50 });
   if (limitFlag.value != null && limit == null) {
-    return { error: "ticker --limit requires a positive number" };
+    return { error: "stocks --limit requires a positive number" };
   }
   if (sortFlag.value != null && !SORTS.includes(sortFlag.value.toLowerCase())) {
-    return { error: `ticker --sort must be one of ${SORTS.join(", ")}` };
+    return { error: `stocks --sort must be one of ${SORTS.join(", ")}` };
   }
   if (horizonFlag.value != null && !["1", "2"].includes(String(horizonFlag.value))) {
-    return { error: "ticker --horizon must be 1 or 2" };
+    return { error: "stocks --horizon must be 1 or 2" };
   }
 
   const stray = rest.find((arg) => arg.startsWith("-") && arg !== "-");
-  if (stray) return { error: `unknown ticker flag ${JSON.stringify(stray)}` };
+  if (stray) return { error: `unknown stocks flag ${JSON.stringify(stray)}` };
 
   const [first, ...tail] = rest;
   if (!first) return { usage: true };
@@ -158,16 +158,16 @@ export function tickerArgs(input = []) {
   const verb = resolveVerb(first);
   const words = verb ? tail : rest;
 
-  // No verb → the first word is the ticker. `/ticker AAPL` is the headline
+  // No verb → the first word is the ticker. `/stocks AAPL` is the headline
   // case and must stay the shortest thing anyone types.
   const wantsReport = verb == null || verb === "report" || verb === "open";
   if (wantsReport) {
     const raw = words[0];
-    if (!raw) return { error: `ticker ${verb === "open" ? "open" : "report"} requires a ticker symbol` };
+    if (!raw) return { error: `stocks ${verb === "open" ? "open" : "report"} requires a ticker symbol` };
     const symbol = normalizeSymbol(raw);
     if (!symbol) {
       return {
-        error: `${JSON.stringify(String(raw))} is not a ticker symbol — try: moshcode ticker lookup ${String(raw)}`,
+        error: `${JSON.stringify(String(raw))} is not a ticker symbol — try: moshcode stocks lookup ${String(raw)}`,
       };
     }
     if (verb === "open") return { verb: "open", symbol, open: `/ticker/${encodeURIComponent(symbol)}`, json };
@@ -176,16 +176,16 @@ export function tickerArgs(input = []) {
 
   if (verb === "signals") {
     const symbol = normalizeSymbol(words[0]);
-    if (!words[0]) return { error: "ticker signals requires a ticker symbol" };
+    if (!words[0]) return { error: "stocks signals requires a ticker symbol" };
     if (!symbol) {
-      return { error: `${JSON.stringify(String(words[0]))} is not a ticker symbol — try: moshcode ticker lookup ${words[0]}` };
+      return { error: `${JSON.stringify(String(words[0]))} is not a ticker symbol — try: moshcode stocks lookup ${words[0]}` };
     }
     return { verb, symbol, path: "/api/signals", query: { ticker: symbol }, json };
   }
 
   if (verb === "search" || verb === "lookup") {
     const q = words.join(" ").trim();
-    if (!q) return { error: `ticker ${verb} requires something to look for` };
+    if (!q) return { error: `stocks ${verb} requires something to look for` };
     const path = verb === "search" ? "/api/search" : "/api/lookup";
     return { verb, path, query: { q, ...(limit ? { limit: String(limit) } : {}) }, json };
   }
@@ -221,7 +221,7 @@ export function tickerArgs(input = []) {
   if (verb === "tickers") return { verb, path: "/api/tickers", query: {}, json };
   if (verb === "stats") return { verb, path: "/api/stats", query: {}, json };
 
-  return { error: `unknown ticker command ${JSON.stringify(String(first))}` };
+  return { error: `unknown stocks command ${JSON.stringify(String(first))}` };
 }
 
 /** Build the absolute URL for a translated request. */
@@ -248,7 +248,7 @@ export async function fetchAdvisor(request, { fetchImpl = globalThis.fetch, base
   try {
     const res = await fetchImpl(url, {
       signal: controller.signal,
-      headers: { accept: "application/json", "user-agent": "moshcode-ticker" },
+      headers: { accept: "application/json", "user-agent": "moshcode-stocks" },
     });
     const text = await res.text();
     let data;
@@ -279,8 +279,18 @@ function compact(v) {
   const n = Number(v);
   if (!Number.isFinite(n)) return null;
   const units = [[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]];
-  for (const [size, suffix] of units) {
-    if (Math.abs(n) >= size) return `${(n / size).toFixed(2).replace(/\.?0+$/, "")}${suffix}`;
+  for (let i = 0; i < units.length; i++) {
+    const [size, suffix] = units[i];
+    if (Math.abs(n) < size) continue;
+    // Rounding to 2 decimals can push a value just under the next boundary up to
+    // a full thousand of this unit (999,999,999 → "1000M"); carry it to the next
+    // unit up (→ "1B") so the number never reads as an un-carried thousand.
+    const scaled = (n / size).toFixed(2);
+    if (Math.abs(Number(scaled)) >= 1000 && i > 0) {
+      const [upSize, upSuffix] = units[i - 1];
+      return `${(n / upSize).toFixed(2).replace(/\.?0+$/, "")}${upSuffix}`;
+    }
+    return `${scaled.replace(/\.?0+$/, "")}${suffix}`;
   }
   return String(n);
 }
@@ -458,7 +468,7 @@ function renderLookup(d) {
     const report = m.hasReport ? acid("  ✓ report") : ash("  · no report yet");
     lines.push(`  ${acid(String(m.symbol).padEnd(8))}${bone(clip(m.name, 44).padEnd(46))}${ash(String(m.exchange ?? ""))}${report}`);
   }
-  lines.push("", `  ${ash("then:")} ${bone(`moshcode ticker ${matches[0].symbol}`)}`);
+  lines.push("", `  ${ash("then:")} ${bone(`moshcode stocks ${matches[0].symbol}`)}`);
   return lines.join("\n");
 }
 
@@ -474,7 +484,7 @@ function renderReports(d) {
       `${bone(money(r.lastPrice).padStart(11))}  ${ash(clip(r.companyName, 28).padEnd(29))}${ash(day(r.generatedAt))}`,
     );
   }
-  lines.push("", `  ${ash("detail:")} ${bone(`moshcode ticker ${reports[0].ticker}`)}`);
+  lines.push("", `  ${ash("detail:")} ${bone(`moshcode stocks ${reports[0].ticker}`)}`);
   return lines.join("\n");
 }
 
@@ -540,12 +550,12 @@ export function renderAdvisor(verb, data, { columns } = {}) {
 }
 
 /**
- * Run a `ticker` invocation end to end. Returns a process exit code.
+ * Run a `stocks` invocation end to end. Returns a process exit code.
  *
  * `deps` exists so tests drive the whole command — parse, fetch, render — with
  * no network and no stdout.
  */
-export async function tickerCommand(argv = [], deps = {}) {
+export async function stocksCommand(argv = [], deps = {}) {
   const {
     out = (s) => console.log(s),
     fail = (s) => console.error(s),
@@ -555,8 +565,8 @@ export async function tickerCommand(argv = [], deps = {}) {
     columns = process.stdout.columns,
   } = deps;
 
-  const request = tickerArgs(argv);
-  if (request.usage) { out(tickerUsage()); return 0; }
+  const request = stocksArgs(argv);
+  if (request.usage) { out(stocksUsage()); return 0; }
   if (request.error) { fail(danger(`✗ ${request.error}`)); return 1; }
 
   if (request.verb === "open") {
@@ -577,7 +587,7 @@ export async function tickerCommand(argv = [], deps = {}) {
     if (request.json) { out(JSON.stringify(res.data, null, 2)); return 1; }
     fail(danger(`✗ ${message}`));
     if (res.data?.didYouMean?.symbol) {
-      fail(`  ${ash("try:")} ${bone(`moshcode ticker ${res.data.didYouMean.symbol}`)}`);
+      fail(`  ${ash("try:")} ${bone(`moshcode stocks ${res.data.didYouMean.symbol}`)}`);
     }
     return 1;
   }

package/src/cli-schema.mjs

@@ -290,14 +290,14 @@ export const CORE_CLI_COMMANDS = [
     note: "buy/sell inject --dry-run unless --submit is present. Alpaca defaults to paper trading; live trading requires its separate --live opt-in.",
   },
   {
-    name: "ticker",
+    name: "stocks",
     group: "tools",
     description: "equity research from advis0r.com",
     synopsis: [
-      ["moshcode ticker <symbol>", "the stored research report for one ticker"],
-      ["moshcode ticker <verb> [args…]", ""],
+      ["moshcode stocks <symbol>", "the stored research report for one ticker"],
+      ["moshcode stocks <verb> [args…]", ""],
     ],
-    verbs: "TICKER_VERBS",
+    verbs: "STOCKS_VERBS",
     flags: [
       ["--json", "print the raw API response", ""],
       ["--limit <n>", "cap results (search/lookup/reports/discover)", "the API's own default"],
@@ -306,16 +306,46 @@ export const CORE_CLI_COMMANDS = [
       ["--provider <p>", "discover: analysis provider", "offline"],
     ],
     examples: [
-      ["moshcode ticker NVDA", "score, technicals, thesis, signals, sources"],
-      ["moshcode ticker lookup rivian", "company name → RIVN"],
-      ["moshcode ticker signals AAPL", "what was actually said, with sources"],
-      ["moshcode ticker search 'data center'", "across every indexed transcript"],
-      ["moshcode ticker reports --limit 10", "the stored index, best score first"],
+      ["moshcode stocks NVDA", "score, technicals, thesis, signals, sources"],
+      ["moshcode stocks lookup rivian", "company name → RIVN"],
+      ["moshcode stocks signals AAPL", "what was actually said, with sources"],
+      ["moshcode stocks search 'data center'", "across every indexed transcript"],
+      ["moshcode stocks reports --limit 10", "the stored index, best score first"],
     ],
     seeAlso: ["trade", "plugin", "tools"],
     note: "research aid, not advice — reports are stored snapshots and every one prints when it was generated. Set MOSHCODE_ADVISOR_URL to point at another instance.",
   },
-  { name: "advisor", aliasOf: "ticker", description: "alias for ticker" },
+  { name: "advisor", aliasOf: "stocks", description: "alias for stocks" },
+  {
+    name: "crypto",
+    group: "tools",
+    description: "crypto market data from advis0r.com",
+    synopsis: [
+      ["moshcode crypto <pair>", "the full report for one pair"],
+      ["moshcode crypto <verb> [args…]", ""],
+    ],
+    verbs: "CRYPTO_VERBS",
+    flags: [
+      ["--json", "print the raw API response", ""],
+      ["--timeframe <tf>", "bars: 1Min | 5Min | 15Min | 1Hour | 1Day | 1Week", "1Day"],
+      ["--start <iso>", "bars: window start", "the API's own default"],
+      ["--end <iso>", "bars: window end", "now"],
+      ["--limit <n>", "cap results (bars/lookup)", "the API's own default"],
+      ["--depth <n>", "book: levels per side", "10"],
+      ["--period <p>", "spark: 24h | 7d", "24h"],
+      ["--horizon <n>", "technicals: quarters the score looks ahead (1 or 2)", "2"],
+    ],
+    examples: [
+      ["moshcode crypto BTC", "price, technicals, score, supply, order book"],
+      ["moshcode crypto lookup bitcoin", "asset name → BTC/USD"],
+      ["moshcode crypto spark BTC ETH SOL", "24h closes as sparklines"],
+      ["moshcode crypto bars ETH --timeframe 1Hour", "historical OHLCV"],
+      ["moshcode crypto book BTC-USD --depth 5", "top of book, both sides"],
+    ],
+    seeAlso: ["stocks", "trade", "plugin"],
+    note: "research aid, not advice — prices are Alpaca's US crypto venue alone and can differ materially from other exchanges. Crypto trades 24/7 with no circuit breakers. Set MOSHCODE_ADVISOR_URL to point at another instance.",
+  },
+  { name: "coins", aliasOf: "crypto", description: "alias for crypto" },
   {
     name: "plugin",
     group: "extend",
@@ -327,7 +357,7 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode plugin install", "add the marketplace and install ticker"],
       ["moshcode plugin list", "what this marketplace ships, and what is installed"],
     ],
-    seeAlso: ["skill", "mcp", "ticker"],
+    seeAlso: ["skill", "mcp", "stocks"],
     note: "Claude Code is the only engine with a plugin primitive; the others are reported as skipped, exactly as they are for skills.",
   },
   { name: "plugins", aliasOf: "plugin", description: "alias for plugin" },
@@ -509,36 +539,72 @@ export const DNS_VERBS = [
 ];
 
 /**
- * `ticker`'s verbs.
+ * `stocks`'s verbs.
  *
  * `report` exists so a symbol that collides with a verb name still has an
  * unambiguous spelling; without it, the bare-symbol shortcut would have no
  * escape hatch. src/advisor.mjs owns the parser and test/advisor.test.mjs
  * fails when the two lists disagree.
  */
-export const TICKER_VERBS = [
-  { name: "report", description: "the stored research report for one ticker", synopsis: [["moshcode ticker report <symbol>", "same as `moshcode ticker <symbol>`"]] },
-  { name: "signals", description: "every extracted signal for a ticker", synopsis: [["moshcode ticker signals <symbol>", ""]] },
+export const STOCKS_VERBS = [
+  { name: "report", description: "the stored research report for one ticker", synopsis: [["moshcode stocks report <symbol>", "same as `moshcode stocks <symbol>`"]] },
+  { name: "signals", description: "every extracted signal for a ticker", synopsis: [["moshcode stocks signals <symbol>", ""]] },
   {
     name: "search", description: "full-text search across indexed transcripts",
-    synopsis: [["moshcode ticker search <words…> [--limit n]", ""]],
+    synopsis: [["moshcode stocks search <words…> [--limit n]", ""]],
   },
   {
     name: "lookup", description: "find a ticker by company name",
-    synopsis: [["moshcode ticker lookup <company…> [--limit n]", "rivian → RIVN"]],
+    synopsis: [["moshcode stocks lookup <company…> [--limit n]", "rivian → RIVN"]],
   },
   {
     name: "reports", description: "every stored report",
-    synopsis: [["moshcode ticker reports [--sort recent|score|ticker] [--limit n]", ""]],
+    synopsis: [["moshcode stocks reports [--sort recent|score|ticker] [--limit n]", ""]],
   },
   {
     name: "discover", description: "a ranked watchlist for a topic",
-    synopsis: [["moshcode ticker discover [topic…] [--horizon 1|2] [--provider p] [--limit n]", ""]],
+    synopsis: [["moshcode stocks discover [topic…] [--horizon 1|2] [--provider p] [--limit n]", ""]],
     note: "ranks by analyzing each candidate — this one takes minutes, not milliseconds.",
   },
-  { name: "tickers", description: "every ticker present in the index", synopsis: [["moshcode ticker tickers", ""]] },
-  { name: "stats", description: "index coverage counts", synopsis: [["moshcode ticker stats", ""]] },
-  { name: "open", description: "open the shareable report page in a browser", synopsis: [["moshcode ticker open <symbol>", ""]] },
+  { name: "tickers", description: "every ticker present in the index", synopsis: [["moshcode stocks tickers", ""]] },
+  { name: "stats", description: "index coverage counts", synopsis: [["moshcode stocks stats", ""]] },
+  { name: "open", description: "open the shareable report page in a browser", synopsis: [["moshcode stocks open <symbol>", ""]] },
+];
+
+/**
+ * `crypto`'s verbs.
+ *
+ * `report` earns its place for the same reason stocks's does — a bare pair is
+ * the shortcut, so a pair that collides with a verb name needs a spelling that
+ * cannot be mistaken for one. src/crypto.mjs owns the parser and
+ * test/crypto.test.mjs fails when the two lists disagree.
+ */
+export const CRYPTO_VERBS = [
+  { name: "report", description: "the full report for one pair", synopsis: [["moshcode crypto report <pair>", "same as `moshcode crypto <pair>`"]] },
+  { name: "quote", description: "latest trade and quote, with the bid/ask spread", synopsis: [["moshcode crypto quote <pair>", ""]] },
+  {
+    name: "snapshot", description: "trade, quote and daily bars for several pairs",
+    synopsis: [["moshcode crypto snapshot <pair…>", "up to 20 pairs"]],
+  },
+  {
+    name: "technicals", description: "indicators and the technical score",
+    synopsis: [["moshcode crypto technicals <pair> [--horizon 1|2]", ""]],
+  },
+  {
+    name: "bars", description: "historical OHLCV",
+    synopsis: [["moshcode crypto bars <pair> [--timeframe tf] [--start iso] [--end iso] [--limit n]", ""]],
+  },
+  { name: "book", description: "top of the order book, both sides", synopsis: [["moshcode crypto book <pair> [--depth n]", ""]] },
+  {
+    name: "spark", description: "recent closes, drawn as sparklines",
+    synopsis: [["moshcode crypto spark <pair…> [--period 24h|7d]", ""]],
+  },
+  { name: "assets", description: "every supported pair", synopsis: [["moshcode crypto assets", ""]] },
+  {
+    name: "lookup", description: "find a pair by asset name",
+    synopsis: [["moshcode crypto lookup <name…> [--limit n]", "bitcoin → BTC/USD"]],
+  },
+  { name: "open", description: "open the shareable page in a browser", synopsis: [["moshcode crypto open <pair>", ""]] },
 ];
 
 export const PLUGIN_VERBS = [
@@ -560,7 +626,8 @@ export const VERB_TABLES = {
   UPGRADE_TARGETS,
   DNS_VERBS,
   TRADE_VERBS,
-  TICKER_VERBS,
+  STOCKS_VERBS,
+  CRYPTO_VERBS,
   PLUGIN_VERBS,
 };
 
@@ -588,8 +655,10 @@ export const PIT_COMMANDS = [
     description: "list workflow tools, or run one" },
   { name: "trade", args: "<verb> [args…]", cli: "trade",
     description: "look up markets and preview/place Alpaca orders" },
-  { name: "ticker", aliases: ["advisor"], args: "<symbol|verb> [args…]", cli: "ticker",
+  { name: "stocks", aliases: ["advisor"], args: "<symbol|verb> [args…]", cli: "stocks",
     description: "equity research from advis0r.com" },
+  { name: "crypto", aliases: ["coins"], args: "<pair|verb> [args…]", cli: "crypto",
+    description: "crypto market data from advis0r.com" },
   { name: "plugin", aliases: ["plugins"], args: "<verb> [name]", cli: "plugin",
     description: "install moshcode's slash commands into Claude Code" },
   { name: "socials", aliases: ["social"], pitOnly: true,