mindvest-atlas 0.68.4 → 0.93.0

package/README.md

@@ -30,6 +30,7 @@ atlas options-chain --symbol SPY --expiration 2026-06-20
 atlas historical-contract --symbol NVDA --expiry 2026-07-13 --strike 205 --side call --from 2026-07-06 --to 2026-07-10
 atlas alerts --symbol SPY --name greek_exposure --save-charts ./charts
 atlas flow stream --symbol NVDA
+atlas phone-notify --title "Backtest done" --body "SPY: 61% win" --key backtest   # your own phone
 ```
 
 ## Layout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.68.4",
+  "version": "0.93.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

@@ -20,6 +20,9 @@ import { screenshotCommand } from './commands/screenshot.js';
 import { runCommand } from './commands/run.js';
 import { computerUseCommand } from './commands/computer-use.js';
 import { dashboardCommand } from './commands/dashboard.js';
+import { chatSearchCommand } from './commands/chat-search.js';
+import { connectorsCommand, connectorCommand } from './commands/connectors.js';
+import { memoryCommand } from './commands/memory.js';
 import { remoteCheckCommand } from './commands/remote-check.js';
 import { shareCommand } from './commands/share.js';
 import { historicalContractCommand } from './commands/historical.js';
@@ -130,6 +133,26 @@ export async function main(rawArgs) {
       // hand (owner, 2026-09-06).
       case 'dashboard':
         return dashboardCommand(withoutCommand(args));
+      // EVERY PAST CONVERSATION ON THIS COMPUTER, read where it lies (owner,
+      // 2026-09-18: "how do I do searching so every agent can search
+      // conversations"). Local files, so no cloud tool could do it; the
+      // running Studio knows where each agent keeps its own.
+      case 'chat-search':
+      case 'chats':
+        return await chatSearchCommand(withoutCommand(args));
+      // THE CONNECTORS ON THIS COMPUTER, brokers among them (owner,
+      // 2026-09-30: "add a CLI for these tools"). Their sign-ins never leave
+      // this machine, so no cloud tool could reach them.
+      case 'connectors':
+        return await connectorsCommand(withoutCommand(args));
+      case 'connector':
+        return await connectorCommand(withoutCommand(args));
+      // WHAT ATLAS KEEPS BETWEEN CONVERSATIONS: three tiers, decayed by use,
+      // weighted 1-10 by whoever is working (owner, 2026-09-19). Local files,
+      // so no cloud tool could do it.
+      case 'memory':
+      case 'mem':
+        return await memoryCommand(withoutCommand(args));
       // Put the newest CLI on this machine.
       case 'update-cli':
       case 'self-update':

package/src/commands/chat-search.js

@@ -0,0 +1,218 @@
+// `atlas chat-search` — every past conversation on this computer, searched
+// where it lies.
+//
+// Owner, 2026-09-18: "let's say I want to continue from another agent and my
+// sessions are not linked, how do I do searching so every agent can search
+// conversations … even ask() or a normal convo can check previous convo."
+//
+// The engine is in Atlas Studio (`main/core/chat-search.ts`) because that is
+// where the stores are known: the adapters' own transcripts, the chats Studio
+// keeps for every model reached over a port or a key (LM Studio, Ollama, any
+// provider), a project's own `.chats`, and whatever its sweep has found. This
+// command is the shell's way in, for the agent that is sitting at a prompt
+// rather than inside a project script — the same road `atlas screenshot` takes
+// to the dashboard.
+//
+// A HAND-WRITTEN COMMAND, DELIBERATELY. The rule is that a verb has to earn
+// one by doing something a cloud tool call cannot (2026-09-15). This reads
+// files on THIS disk; there is no cloud tool that could.
+//
+// NOTHING IS SHORTENED ON THE WAY THROUGH (owner, 2026-09-18: "DO NOT TRUNCATE
+// OR CUT"). Whatever the engine returns is printed whole; when there is too
+// much, the engine returns FEWER WHOLE TURNS and says so, and that sentence is
+// printed too.
+import { color, println, eprintln } from '../util/ui.js';
+import { askAddress } from '../remote-control.js';
+
+function notRunning() {
+  eprintln(color.red('Atlas Studio is not running on this computer.'));
+  eprintln(color.dim('It is what knows where each agent keeps its conversations. Start it and try again.'));
+  return 1;
+}
+
+async function post(at, path, body) {
+  const res = await fetch(at.url.replace('/ask', path), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': at.token },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(180_000),
+  });
+  const out = await res.json().catch(() => ({}));
+  if (!res.ok || !out.ok) throw new Error(out.error || `Chat search failed (${res.status}).`);
+  return out;
+}
+
+function printRows(rows, agent) {
+  for (const row of rows) {
+    const who = row.kind === 'user'
+      ? 'You'
+      : row.kind === 'assistant'
+        ? (agent || 'Model')
+        : `${row.kind === 'tool_call' ? 'Tool call' : 'Tool result'}: ${row.tool || 'tool'}`;
+    println(color.dim(`--- ${who} ---`));
+    println(row.text);
+    println('');
+  }
+}
+
+export async function chatSearchCommand(args) {
+  const flags = args.flags || {};
+  const at = askAddress(flags.root);
+  if (!at) return notRunning();
+
+  const sub = String((args.positional ?? args._)?.[0] || '').trim();
+
+  // WHAT THIS COMPUTER REMEMBERS about searching: which folders hold
+  // conversations, which of them answer, and where recent answers were. Paths
+  // and counters, never a conversation (owner, 2026-09-19: "store the search
+  // path or recent important stuff, so we can read this to find info quicker
+  // next time").
+  if (sub === 'forget') {
+    try {
+      await post(at, '/chat-search/forget', {});
+      println('Forgotten. Every conversation is exactly where it was; only the shortcuts are gone.');
+      return 0;
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+  }
+  if (sub === 'memory' || sub === 'places') {
+    let mem;
+    try {
+      mem = await post(at, '/chat-search/memory', {});
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+    if (flags.json) {
+      println(JSON.stringify(mem, null, 2));
+      return 0;
+    }
+    println(color.bold(`${mem.places.length} place(s) learned, ${mem.recent.length} pointer(s) kept`));
+    for (const p of mem.places) {
+      println(`  ${p.dir}  ${color.dim(`${p.agent} · ${p.parser}${p.hits ? ` · answered ${p.hits}x` : ''}`)}`);
+    }
+    for (const r of mem.recent.slice(0, 10)) {
+      println(`  "${r.query}" -> ${r.sessionId} ${color.dim(`(${r.agent} · ${r.store})`)}`);
+    }
+    return 0;
+  }
+
+  // `chat-search show <session>` — one conversation, as deep as asked. Its own
+  // call rather than a flag, because reading a conversation whole is a
+  // different act from finding one.
+  if (sub === 'show' || flags.show) {
+    const id = String(flags.show || (args.positional ?? args._)?.[1] || '').trim();
+    if (!id) {
+      eprintln(color.red('Which conversation? `atlas chat-search show <session-id>`'));
+      return 1;
+    }
+    let out;
+    try {
+      out = await post(at, '/chat-search/show', {
+        sessionId: id,
+        file: flags.file,
+        around: flags.around == null ? undefined : Number(flags.around),
+        // `--turns 0` is the whole thing; the default keeps it to the part
+        // around the start.
+        turns: flags.turns == null ? undefined : Number(flags.turns),
+        handover: !!flags.handover,
+        discover: !!flags.discover,
+      });
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+    if (flags.json) {
+      println(JSON.stringify(out, null, 2));
+      return 0;
+    }
+    if (flags.handover) {
+      // Exactly what you paste into another model as the first message.
+      println(out.handover);
+      return 0;
+    }
+    println(color.bold(out.title));
+    println(color.dim(`${out.agent} · ${out.store} · ${out.sessionId}${out.cwd ? ` · ${out.cwd}` : ''}`));
+    println(color.dim(`Turns ${out.from}-${out.to} of ${out.total}. Nothing below is shortened.`));
+    println('');
+    printRows(out.rows, out.agent);
+    return 0;
+  }
+
+  const query = String(flags.query || flags.q || (args.positional ?? args._)?.join(' ') || '').trim();
+  if (!query) {
+    eprintln(color.red('What are you looking for? `atlas chat-search "the words you remember"`'));
+    eprintln(color.dim('Then: atlas chat-search show <session> --turns 0    (the whole conversation)'));
+    return 1;
+  }
+
+  let out;
+  try {
+    out = await post(at, '/chat-search', {
+      query,
+      turns: flags.turns == null ? undefined : Number(flags.turns),
+      limit: flags.limit == null ? undefined : Number(flags.limit),
+      maxBytes: flags.bytes == null ? undefined : Number(flags.bytes),
+      store: flags.store,
+      agent: flags.agent,
+      since: flags.since ? Date.parse(String(flags.since)) || undefined : undefined,
+      matchCase: !!flags['match-case'],
+      regex: !!flags.regex,
+      // Look for stores nobody wrote a path for, unless told not to. What it
+      // finds is remembered as a FOLDER, so the next search already knows.
+      discover: flags['no-discover'] ? false : true,
+      // The project you are in comes first; everything else still comes back.
+      project: flags.project || flags.job || process.cwd(),
+      maxMs: flags.ms == null ? undefined : Number(flags.ms),
+    });
+  } catch (err) {
+    eprintln(color.red(err.message));
+    return 1;
+  }
+
+  if (flags.json) {
+    println(JSON.stringify(out, null, 2));
+    return 0;
+  }
+
+  if (!out.hits.length) {
+    println(`Nothing on this computer says "${query}".`);
+    println(color.dim(`Looked in ${out.scanned.places} place(s), ${out.scanned.files} transcript(s).`));
+    for (const note of out.notes) println(color.dim(note));
+    return 0;
+  }
+
+  // SEEN BEFORE. Offered beside the live answer, never instead of it: a store
+  // can change under a pointer.
+  if (out.remembered?.length) {
+    println(color.dim('Seen before:'));
+    for (const r of out.remembered) {
+      println(color.dim(`  "${r.query}" -> ${r.sessionId} (${r.agent} · ${r.store})`));
+    }
+    println('');
+  }
+
+  println(color.bold(`${out.hits.length} of ${out.found} conversation(s)`));
+  println('');
+  for (const hit of out.hits) {
+    println(color.bold(hit.title));
+    println(color.dim(`${hit.agent} · ${hit.store} · ${new Date(hit.updatedAt).toLocaleString()} · ${hit.matches} match(es)`));
+    println(color.dim(`session ${hit.sessionId}${hit.cwd ? ` · ${hit.cwd}` : ''}`));
+    // The matching line verbatim — or, when that ONE line is enormous, where to
+    // find it, because showing part of it would be showing part of a value.
+    println(hit.line == null
+      ? color.dim(`  [one line of ${hit.lineIsHuge?.bytes} bytes. Read it whole: atlas chat-search show ${hit.sessionId} --turns 0]`)
+      : `  ${hit.line}`);
+    if (!flags.quiet) {
+      println('');
+      printRows(hit.rows, hit.agent);
+      if (hit.note) println(color.yellow(hit.note));
+      println(color.dim(`Turns ${hit.from}-${hit.to} of ${hit.total}. atlas chat-search show ${hit.sessionId} --turns 0 for all of it.`));
+    }
+    println('');
+  }
+  for (const note of out.notes) println(color.dim(note));
+  return 0;
+}