mindvest-atlas 0.67.0 → 0.68.0

package/package.json

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

package/src/cli.js

@@ -12,6 +12,7 @@ import { whoamiCommand } from './commands/whoami.js';
 import { toolsCommand } from './commands/tools.js';
 import { modelsCommand, askCommand } from './commands/models.js';
 import { alertsCommand } from './commands/alerts.js';
+import { signalsCommand } from './commands/signals.js';
 import { flowCommand } from './commands/flow.js';
 import { remoteControlCommand } from './commands/remote-control.js';
 import { updateCliCommand } from './commands/update-cli.js';
@@ -88,6 +89,10 @@ export async function main(rawArgs) {
       case 'models': return await modelsCommand(withoutCommand(args));
       case 'ask': return await askCommand(withoutCommand(args));
       case 'alerts': return await alertsCommand(withoutCommand(args));
+      // Plays: groups, the board, a group's record, and closing one down.
+      case 'signals':
+      case 'plays':
+        return await signalsCommand(withoutCommand(args));
       case 'flow': return await flowCommand(withoutCommand(args));
       // Long-lived: hold the job stream and run this computer's jobs.
       // Walk the whole loop and say which hop fails.

package/src/commands/alerts.js

@@ -12,7 +12,8 @@ import path from 'node:path';
 import { API } from '../config.js';
 import { runStream } from '../util/stream-loop.js';
 import { formatAlert } from '../util/format.js';
-import { color, println, eprintln } from '../util/ui.js';
+import { color, println, eprintln, prettyJson } from '../util/ui.js';
+import { requestJson } from '../api/client.js';
 import * as background from '../util/background.js';
 
 // Names the slot, the claim file and the log, and it is the command's own name
@@ -25,8 +26,66 @@ function sanitizeFilename(name) {
   return String(name || '').replace(/[^A-Za-z0-9._-]/g, '_') || 'alert.png';
 }
 
+// ── list / delete ────────────────────────────────────────────────────────────
+const callTool = (name, body) => requestJson(API.tool(name), { method: 'POST', body: body || {} });
+
+async function listAlerts(flags) {
+  const data = await callTool('List-Alerts', {
+    ...(flags.all ? { active_only: false } : {}),
+    ...(flags.symbol ? { symbol: String(flags.symbol).toUpperCase() } : {}),
+  });
+  if (flags.json) { println(prettyJson(data)); return 0; }
+  const list = (data && (data.alerts || data.data)) || (Array.isArray(data) ? data : []);
+  if (!list.length) { println(color.dim('No alerts.')); return 0; }
+  for (const a of list) {
+    const state = a.is_active === false ? color.dim('off') : color.green('on');
+    println(`${state}  ${color.bold(a.name || '(unnamed)')}  ${color.dim([a.symbol, a.alert_type].filter(Boolean).join(' · '))}`);
+    println(color.dim(`     ${a.id}`));
+  }
+  println('');
+  println(color.dim('Switch one off:  atlas alerts delete --id <id>'));
+  println(color.dim('Delete for good: atlas alerts delete --id <id> --purge'));
+  return 0;
+}
+
+async function deleteAlerts(args) {
+  const flags = args.flags;
+  // --id may repeat; extra positionals after the verb are ids too, so
+  // `atlas alerts delete a b c` does what it looks like it does.
+  const fromFlags = flags.id === undefined ? [] : (Array.isArray(flags.id) ? flags.id : [flags.id]);
+  const ids = [...fromFlags, ...(args._ || []).slice(1)]
+    .map((x) => String(x || '').trim())
+    .filter((x) => x && x !== 'true');
+  if (!ids.length) {
+    eprintln(color.red('Which alert? --id <id> (repeat for several), or list them: atlas alerts list'));
+    return 1;
+  }
+  const purge = !!flags.purge;
+  const data = await callTool('Delete-Alert', {
+    alert_ids: ids, purge,
+  });
+  if (data && data.error) { eprintln(color.red(String(data.error))); return 1; }
+  if (flags.json) { println(prettyJson(data)); return 0; }
+  println(data.message || (purge ? 'Deleted.' : 'Switched off.'));
+  // A purge that kept some says why, and the message already names them; this
+  // points at the way through rather than leaving the user to guess.
+  if (data.kept && Object.keys(data.kept).length) {
+    println(color.dim('Repoint those setups, or drop --purge to just switch the alert off.'));
+  }
+  return 0;
+}
+
 export async function alertsCommand(args) {
   const flags = args.flags;
+  // MANAGING alerts, not watching them. A bare `atlas alerts` has meant "open
+  // the live feed" since it shipped, so the stream stays the default and the
+  // two management verbs are positionals in front of it. Without these the
+  // only way to clear out a spoiled alert was to know the tool slug by heart
+  // (owner, 2026-09-12: "it's hard to manage spoiled alerts without a
+  // something to delete them").
+  const verb = String((args._ && args._[0]) || '').toLowerCase();
+  if (verb === 'list' || verb === 'ls') return await listAlerts(flags);
+  if (verb === 'delete' || verb === 'rm' || verb === 'off') return await deleteAlerts(args);
   if (flags.stop) return background.stop(SLOT);
   if (flags.detach) return background.detach(SLOT);
   const holder = background.holdUntilStopped(SLOT);

package/src/commands/signals.js

@@ -0,0 +1,201 @@
+// `atlas signals …` — the plays surface as real commands.
+//
+// Owner, 2026-09-12: *"CLI need update if not the actions and doc will not see
+// it — it needs commands."* Every tool has always been callable as
+// `atlas <slug> --flag value`, so the plays tools worked; what did not work was
+// FINDING them. `atlas --help` listed no plays at all, so an agent (or a
+// person) reading the CLI concluded there was no way to see a group's record or
+// to close one down.
+//
+// These are thin: each subcommand is one tool call with the flags spelled the
+// way a person would say them, and a printed answer rather than a JSON dump.
+// `--json` gives the raw body for scripts.
+import { API } from '../config.js';
+import { requestJson } from '../api/client.js';
+import { color, println, eprintln, prettyJson } from '../util/ui.js';
+
+const HELP = `${color.bold('atlas signals')} — plays: your groups, the board, and what they have made
+
+${color.bold('USAGE')}
+  atlas signals <command> [options]
+
+${color.bold('COMMANDS')}
+  groups                              The groups you can post to, and the ones you follow
+  plays [--board community|private]   The plays themselves  [--days N] [--limit N]
+  show --id <play>                    One play, as a card
+  take --id <play> [--contracts N]    Place a play in YOUR account  [--account <id>]
+  performance --group <id> [--mine]   Closed trades and the win rate for a group
+  delete --group <id>                 Delete a group you own
+        [--stop-subscribers]          …stopping the subscriptions first
+  discover                            Public groups other people run
+  follow --group <id> [--off]         Follow a public group, or stop
+  schema                              What a play is made of — read before posting
+
+${color.bold('EXAMPLES')}
+  atlas signals groups
+  atlas signals plays --board community --days 1
+  atlas signals performance --group <id>
+  atlas signals delete --group <id> --stop-subscribers
+`;
+
+const callTool = (name, body) => requestJson(API.tool(name), { method: 'POST', body: body || {} });
+
+// A tool answers with its own {success:false,error} rather than an HTTP error,
+// so every subcommand checks the body, not just the status.
+function failed(data) {
+  return data && typeof data === 'object' && data.success === false;
+}
+function printFailure(data) {
+  eprintln(color.red(String(data.error || 'That did not work.')));
+  if (data.how_to_proceed) eprintln(color.dim(String(data.how_to_proceed)));
+  return 1;
+}
+
+const num = (v) => (v === undefined || v === null || v === '' ? null : Number(v));
+const money = (n) => (n === null || n === undefined || Number.isNaN(Number(n))
+  ? '—'
+  : `${Number(n) < 0 ? '-' : ''}$${Math.abs(Number(n)).toLocaleString('en-US', { maximumFractionDigits: 2 })}`);
+
+function rows(list) {
+  return Array.isArray(list) ? list : (list && Array.isArray(list.signals) ? list.signals : []);
+}
+
+export async function signalsCommand(args) {
+  const flags = args.flags || {};
+  const sub = String(args._[0] || 'groups').toLowerCase();
+  if (flags.help || sub === 'help') { println(HELP); return 0; }
+  const json = !!flags.json;
+  const groupId = flags.group || flags['group-id'] || flags.id;
+
+  switch (sub) {
+    case 'groups': {
+      const data = await callTool('Signal-Groups', {});
+      if (failed(data)) return printFailure(data);
+      if (json) { println(prettyJson(data)); return 0; }
+      const list = data.groups || data.data || [];
+      if (!list.length) { println(color.dim('No groups yet. The community board is always there: atlas signals plays --board community')); return 0; }
+      for (const g of list) {
+        const bits = [g.role, g.visibility, g.signal_count != null ? `${g.signal_count} plays` : null].filter(Boolean);
+        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim(bits.join(' · '))}`);
+        println(color.dim(`  ${g.id}`));
+      }
+      return 0;
+    }
+    case 'plays':
+    case 'list': {
+      const body = {};
+      if (flags.board) body.board = String(flags.board);
+      if (flags.group) body.group_id = String(flags.group);
+      if (flags.days !== undefined) body.days = num(flags.days);
+      if (flags.limit !== undefined) body.limit = num(flags.limit);
+      const data = await callTool('Signal-List', body);
+      if (failed(data)) return printFailure(data);
+      if (json) { println(prettyJson(data)); return 0; }
+      const list = rows(data.plays || data.signals || data);
+      if (!list.length) { println(color.dim('Nothing on that board in that window.')); return 0; }
+      for (const s of list) {
+        const p = s.payload || s;
+        const what = [p.side, p.symbol, p.strike ? `$${p.strike}` : null, (p.option_type || '').toUpperCase() || null,
+          p.expiration_date || p.expiry || null].filter(Boolean).join(' ');
+        println(`${color.bold(what || '(play)')}  ${color.dim(s.status || '')}`);
+        println(color.dim(`  ${s.id}${s.posted_at ? '  ' + s.posted_at : ''}`));
+      }
+      return 0;
+    }
+    case 'show': {
+      const id = flags.id || flags.play || flags.signal;
+      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
+      const data = await callTool('Signal-Show', { signal_id: String(id) });
+      if (failed(data)) return printFailure(data);
+      println(prettyJson(data));
+      return 0;
+    }
+    case 'take': {
+      const id = flags.id || flags.play || flags.signal;
+      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
+      const body = { signal_id: String(id) };
+      if (flags.contracts !== undefined) body.contracts = num(flags.contracts);
+      if (flags.account) body.account_id = String(flags.account);
+      const data = await callTool('Signal-Take', body);
+      if (failed(data)) return printFailure(data);
+      println(json ? prettyJson(data) : (data.message || 'Taken.'));
+      return 0;
+    }
+    case 'performance':
+    case 'perf': {
+      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
+      const data = await callTool('Signal-Group-Performance', {
+        group_id: String(groupId), mine: !!flags.mine,
+      });
+      if (failed(data)) return printFailure(data);
+      if (json) { println(prettyJson(data)); return 0; }
+      const t = data.totals || {};
+      const name = data.display_name || data.name || 'this group';
+      const whose = data.whose === 'mine' ? 'your own trades' : "the author's record";
+      println(`${color.bold(name)} ${color.dim('— ' + whose)}`);
+      println(`  Closed trades  ${(data.rows || []).length}`);
+      println(`  Win rate       ${t.win_rate ?? 0}%  ${color.dim(`(${t.win_count ?? 0} up, ${t.loss_count ?? 0} down)`)}`);
+      println(`  Total          ${money(t.total_pnl)}  ${color.dim(`${t.total_pnl_pct ?? 0}%`)}`);
+      if (data.viewer_has_rows && data.whose !== 'mine') {
+        println(color.dim('  You have taken plays here too: add --mine for your own numbers.'));
+      }
+      return 0;
+    }
+    case 'delete':
+    case 'rm': {
+      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
+      const stop = !!(flags['stop-subscribers'] || flags.stop);
+      const data = await callTool('Signal-Group-Delete', {
+        group_id: String(groupId), stop_subscribers: stop,
+      });
+      if (failed(data)) {
+        // THE REFUSAL WITH AN ANSWER. People are subscribed: say how many, say
+        // what stopping them costs them, and print the line that does it —
+        // rather than an error that names a screen this person is not looking at.
+        if (data.code === 'has_subscribers') {
+          const n = Number(data.subscriber_count) || 1;
+          eprintln(color.yellow(`${n} ${n === 1 ? 'person is' : 'people are'} subscribed to this group.`));
+          eprintln(color.dim('Deleting stops their billing at once, so there is no next payment, and they'
+            + ' lose the rest of the month they paid for. Anything they already traded is theirs.'));
+          eprintln('');
+          eprintln('  ' + color.cyan(`atlas signals delete --group ${groupId} --stop-subscribers`));
+          return 1;
+        }
+        return printFailure(data);
+      }
+      println(json ? prettyJson(data) : (data.message || 'Group deleted.'));
+      return 0;
+    }
+    case 'discover': {
+      const data = await callTool('Signal-Discover', {});
+      if (failed(data)) return printFailure(data);
+      if (json) { println(prettyJson(data)); return 0; }
+      const list = data.groups || [];
+      if (!list.length) { println(color.dim('No public groups yet.')); return 0; }
+      for (const g of list) {
+        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim([g.owner_label, `${g.follower_count ?? 0} following`].filter(Boolean).join(' · '))}`);
+        println(color.dim(`  ${g.id}`));
+      }
+      return 0;
+    }
+    case 'follow': {
+      if (!groupId) { eprintln(color.red('Which group? --group <id>')); return 1; }
+      const data = await callTool('Signal-Follow', {
+        group_id: String(groupId), follow: flags.off ? false : flags.follow !== false,
+      });
+      if (failed(data)) return printFailure(data);
+      println(json ? prettyJson(data) : (data.message || 'Done.'));
+      return 0;
+    }
+    case 'schema': {
+      const data = await callTool('Signal-Schema', {});
+      if (failed(data)) return printFailure(data);
+      println(typeof data === 'string' ? data : prettyJson(data));
+      return 0;
+    }
+    default:
+      eprintln(color.red(`Unknown: atlas signals ${sub}`));
+      println(HELP);
+      return 1;
+  }
+}

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.67.0';
+export const VERSION = '0.68.0';
 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

@@ -27,7 +27,17 @@ export function printRootHelp() {
   println('        --strike 205 --side call --from 2026-07-06 [--to 2026-07-10]  for ONE option contract');
   println('        [--no-greeks] [--json]');
   println();
+  println(c.bold('PLAYS (SIGNALS)'));
+  println('  signals groups                                     Groups you post to, and the ones you follow');
+  println('  signals plays [--board community|private]          The plays [--days N] [--limit N]');
+  println('  signals performance --group <id> [--mine]          A group\'s closed trades and win rate');
+  println('  signals delete --group <id> [--stop-subscribers]   Delete a group (stops subscriptions first)');
+  println('  signals take --id <play> [--contracts N]           Place a play in your account');
+  println('  signals <discover|follow|show|schema>              ' + c.dim('atlas signals help for all of it'));
+  println();
   println(c.bold('STREAMS'));
+  println('  alerts list [--all] [--symbol SPY]                 Your alerts, with their ids');
+  println('  alerts delete --id <id> [--id <id2>] [--purge]     Switch alerts off, or delete for good');
   println('  alerts [--symbol SPY] [--name greek_exposure]      Live alert feed (SSE)');
   println('         [--save-charts <dir>] [--no-chart] [--json]');
   println('         [--detach] [--stop]                        Stream in the background, or stop it');
@@ -59,6 +69,8 @@ export function printRootHelp() {
   println(c.dim('  atlas workflow-create --name "FOMC day" --run-once-at "2026-09-17 14:00" --tools Stock-Quote --instruction "…"   # once, at specific dates/times; --trigger-source manual = Run now only'));
   println(c.dim('  atlas alerts --symbol SPY --name greek_exposure --save-charts ./charts'));
   println(c.dim('  atlas flow stream --symbol NVDA'));
+  println(c.dim('  atlas signals performance --group <id>'));
+  println(c.dim('  atlas signals delete --group <id> --stop-subscribers'));
 }
 
 // Parse the `Args:` block of a tool docstring into { paramName: description }.