mindvest-atlas 0.1.0 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Atlas CLI — OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/commands/call.js

@@ -10,7 +10,48 @@ import { color, println, eprintln, prettyJson, redactBase64 } from '../util/ui.j
 
 const RESERVED = new Set(['help', 'h', 'json', 'out', 'save-charts', 'raw', 'base-url', 'version', 'v']);
 
+// Detect a chart payload in a tool response — top level, MCP structuredContent,
+// a `data` block, or a per-image `data`/inline entry (heatmaps put chart_family
+// inline in images[]). Returns the renderable node, or null.
+function chartNodeOf(o) {
+  if (!o || typeof o !== 'object' || Array.isArray(o)) return null;
+  if (Array.isArray(o.charts) && o.charts.length) return o;
+  if (typeof o.chart_family === 'string' && o.chart_family) return o;
+  return null;
+}
+function maybeWriteChartSink(data) {
+  const sink = process.env.ATLAS_CHART_SINK;
+  if (!sink || !data || typeof data !== 'object') return;
+  let chart =
+    chartNodeOf(data) ||
+    chartNodeOf(data.structuredContent) ||
+    chartNodeOf(data.structured_content) ||
+    chartNodeOf(data.data);
+  if (!chart && Array.isArray(data.images)) {
+    const cs = data.images
+      .map((e) => (e && typeof e === 'object' ? chartNodeOf(e) || chartNodeOf(e.data) : null))
+      .filter(Boolean);
+    if (cs.length) chart = { charts: cs };
+  }
+  if (!chart) return;
+  try {
+    fs.mkdirSync(path.dirname(sink), { recursive: true });
+    // APPEND one JSON line per chart (JSONL) — never overwrite. Two chart tool
+    // calls in the SAME turn each land their own line, so the Studio watcher
+    // captures BOTH; an overwrite lost the first when the second raced in
+    // before the watcher read it (the "multi-chart-per-turn never rendered"
+    // bug). The host reads the file whole and fires each new line.
+    fs.appendFileSync(sink, JSON.stringify({ at: Date.now(), payload: chart }) + '\n');
+  } catch {
+    /* UI-only side channel — never fail the command */
+  }
+}
+
+// Coerce one flag value to the schema type. A value that arrived as an array
+// (a repeated flag, e.g. `--tag a --tag b`) maps element-wise — so array params
+// need no JSON. Unknown/string types still accept an inline JSON array/object.
 function coerce(raw, type) {
+  if (Array.isArray(raw)) return raw.map((x) => coerce(x, type === 'array' ? 'string' : type));
   if (raw === true || raw === false) return raw;
   const s = String(raw);
   if (type === 'integer') {
@@ -31,9 +72,36 @@ function coerce(raw, type) {
   return s;
 }
 
+// A nested value (from a dotted flag like `--updates.is-active true`) carries no
+// schema type, so infer the obvious one: booleans, plain numbers, inline JSON,
+// else the string verbatim. This lets a flag express a nested body with no JSON
+// at all; `--json '{…}'` stays for exact control over an ambiguous value.
+function looseScalar(raw) {
+  if (raw === true || raw === false) return raw;
+  if (Array.isArray(raw)) return raw.map(looseScalar);
+  const s = String(raw);
+  if (/^(true|false)$/i.test(s)) return /^true$/i.test(s);
+  if (/^-?\d+$/.test(s)) return parseInt(s, 10);
+  if (/^-?(?:\d+\.\d*|\.\d+)$/.test(s)) return Number(s);
+  if (s.startsWith('[') || s.startsWith('{')) { try { return JSON.parse(s); } catch { return s; } }
+  return s;
+}
+
 const norm = (s) => s.replace(/-/g, '_');
 
-function buildBody(tool, flags) {
+// Set a value at a dotted path, creating intermediate objects as needed. Each
+// segment is hyphen-normalised, so `--bracket.stop-loss` → bracket.stop_loss.
+function setPath(obj, segs, value) {
+  let cur = obj;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const k = segs[i];
+    if (typeof cur[k] !== 'object' || cur[k] === null || Array.isArray(cur[k])) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[segs[segs.length - 1]] = value;
+}
+
+export function buildBody(tool, flags) {
   const params = tool.parameters || {};
   const byNorm = {};
   for (const p of Object.keys(params)) byNorm[norm(p)] = p;
@@ -41,6 +109,12 @@ function buildBody(tool, flags) {
   const body = {};
   for (const [key, val] of Object.entries(flags)) {
     if (RESERVED.has(key)) continue;
+    // Dotted flag → nested object: `--updates.is-active true` builds
+    // { updates: { is_active: true } } so even nested bodies need no JSON.
+    if (key.includes('.')) {
+      setPath(body, key.split('.').map(norm), looseScalar(val));
+      continue;
+    }
     const pname = params[key] ? key : byNorm[norm(key)];
     if (pname) {
       body[pname] = coerce(val, (params[pname].type) || 'string');
@@ -140,6 +214,12 @@ export async function callCommand(toolSlug, args) {
     return 1;
   }
 
+  // UI side-channel: when a host (Atlas Studio) sets ATLAS_CHART_SINK, write the
+  // chart payload there so the app renders the interactive widget — for EVERY
+  // caller and model, whether this CLI runs directly or behind a wrapper shim.
+  // Purely additive; never alters stdout or fails the command.
+  maybeWriteChartSink(data);
+
   // Save chart images if requested.
   const outDir = (typeof flags.out === 'string' && flags.out) || (typeof flags['save-charts'] === 'string' && flags['save-charts']);
   if (outDir) {

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.1';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/util/help.js

@@ -17,9 +17,10 @@ export function printRootHelp() {
   println('  whoami                                             Show the signed-in account');
   println();
   println(c.bold('TOOLS'));
-  println('  tools [--search <q>] [--json] [--refresh]          List available tools');
+  println('  tools [--search <q>] [--refresh]                   List available tools');
   println('  <tool> --help                                      Show a tool\'s parameters');
-  println('  <tool> [--param value] [--json] [--out <dir>]      Call a tool');
+  println('  <tool> --param value [--out <dir>]                 Call a tool — pass params as flags');
+  println('  <tool> --a.b value                                 Nested value via a dotted flag');
   println();
   println(c.bold('STREAMS'));
   println('  alerts [--symbol SPY] [--name greek_exposure]      Live alert feed (SSE)');
@@ -41,6 +42,7 @@ export function printRootHelp() {
   println(c.dim('  atlas tools'));
   println(c.dim('  atlas stock-quote --symbol SPY'));
   println(c.dim('  atlas options-chain --symbol SPY --expiration 2026-06-20'));
+  println(c.dim('  atlas update-alert --alert-id <id> --updates.is-active true   # nested via a dotted flag'));
   println(c.dim('  atlas alerts --symbol SPY --name greek_exposure --save-charts ./charts'));
   println(c.dim('  atlas flow stream --symbol NVDA'));
 }
@@ -101,9 +103,21 @@ export function printToolHelp(name, tool) {
       if (argDescs[p]) println('  ' + ' '.repeat(flagWidth) + c.dim(argDescs[p]));
     }
     println();
+
+    // A concrete, copy-pasteable EXAMPLE in flag form — what to model, NOT a
+    // JSON body. Prefer required params; otherwise show the first couple.
+    const entries = Object.entries(params);
+    const required = entries.filter(([, m]) => m.required);
+    const chosen = (required.length ? required : entries).slice(0, 3);
+    const example = chosen.map(([p, m]) => `${flagForm(p)} <${m.type || 'string'}>`).join(' ');
+    println(c.bold('EXAMPLE'));
+    println('  ' + c.cyan(`atlas ${slug}${example ? ' ' + example : ''}`));
+    println();
   } else {
     println(c.dim('This tool takes no parameters.'));
     println();
   }
-  println(c.dim('Tip: pass a full JSON body with ') + c.cyan(`atlas ${slug} --json '{"...":...}'`));
+  println(c.dim('Pass each parameter as a flag (above). A nested value uses a dotted flag, e.g. '));
+  println('  ' + c.cyan(`atlas ${slug} --updates.is-active true`) + c.dim('   (→ {"updates":{"is_active":true}})'));
+  println(c.dim('Advanced: ') + c.cyan(`--json '{…}'`) + c.dim(' sends a full body verbatim.'));
 }