mindvest-atlas 0.9.2 → 0.10.0

package/package.json

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

package/src/commands/remote-control.js

@@ -18,6 +18,7 @@ import {
   DEFAULT_TIMEOUT_MS, claimRun, computerName, isPaused, jobEnv, listJobFiles, listRuns, machineId,
   osLabel, readJobFile, releaseRun, staleness, summarize, tail, workspace, workspaceRoot,
   setPaused, writeHelpers, askModel, listModels, chatModel,
+  createProject, listChats, readChat, deleteChat, appendChat,
 } from '../remote-control.js';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -117,12 +118,28 @@ async function handleAsk(ask, root) {
     // event is answered SEPARATELY against the same request id, so the web sees
     // the build as it happens; the server relays and stores none of it.
     let seq = 0;
-    const send = (ev) => answer(ask.request_id, { ok: true, stream: true, seq: ++seq, ...ev });
-    void chatModel(ask.prompt || '', send, { job: ask.job || '', model: ask.model || '' })
+    const job = ask.job || '';
+    const chatId = ask.chat_id || '';
+    // Keep the reply as it streams, so the whole answer can be written to the
+    // transcript once the turn is done.
+    const said = [];
+    const send = (ev) => {
+      if (ev.kind === 'text') said.push(ev.chunk || '');
+      return answer(ask.request_id, { ok: true, stream: true, seq: ++seq, ...ev });
+    };
+    if (job && chatId) appendChat(job, chatId, 'user', ask.prompt || '', root);
+    void chatModel(ask.prompt || '', send, { job, model: ask.model || '' })
       .catch((err) => send({ kind: 'error', message: String(err?.message || err) }))
-      .finally(() => send({ kind: 'done' }));
+      .finally(() => {
+        if (job && chatId) appendChat(job, chatId, 'assistant', said.join(''), root);
+        send({ kind: 'done' });
+      });
     return undefined;
   }
+  if (ask.op === 'create') return answer(ask.request_id, createProject(ask.job || '', root));
+  if (ask.op === 'chats') return answer(ask.request_id, { ok: true, chats: listChats(ask.job || '', root) });
+  if (ask.op === 'chat_read') return answer(ask.request_id, readChat(ask.job || '', ask.chat_id || '', root));
+  if (ask.op === 'chat_delete') return answer(ask.request_id, deleteChat(ask.job || '', ask.chat_id || '', root));
   if (ask.op === 'models') {
     void listModels().then((m) => answer(ask.request_id, { ok: true, ...m }));
     return undefined;

package/src/remote-control.js

@@ -592,3 +592,142 @@ export async function chatModel(prompt, onEvent, { job = '', model = '', timeout
     onEvent({ kind: 'error', message: String(err?.message || err) });
   }
 }
+
+// The starter a project gets the moment it is created, so an agent opening the
+// folder finds a shape to work in rather than an empty directory. Nothing here
+// runs: it is scaffolding, the model replaces main.* on the first build.
+const STARTER_README = (name) => [
+  `# ${name}`, '',
+  'What this does', '--------------',
+  '(Describe it here in your own words. The model reads this when it builds.)', '',
+  'Files', '-----',
+  '- `main.py`        what runs. Replaced by the model on the first build.',
+  '- `.env`           your keys. Values stay on this computer and are never read',
+  '                   back by anything, including the model.',
+  '- `atlas_env.py`   helpers: secret(), require(), atlas(), ask().',
+  '- `flow.md`        a diagram of what happens, written after the first build.', '',
+  'Nothing here is stored on Atlas servers.', '',
+].join('\n');
+
+const STARTER_MAIN = (name) => [
+  '"""' + name + ' - not built yet.', '',
+  'Describe what you want in the chat and the model writes this file, runs it and',
+  'fixes it until it works. Anything already here is replaced.',
+  '"""',
+  'print("Nothing built yet. Describe what this should do in Atlas.")', '',
+].join('\n');
+
+const STARTER_FLOW = (name) => [
+  `# ${name}`, '', '```mermaid', 'flowchart TD',
+  '    A[Not built yet] --> B[Describe it in Atlas]',
+  '    B --> C[The model writes and tests it here]', '```', '',
+].join('\n');
+
+/**
+ * Make a project folder with enough in it to start from.
+ *
+ * An empty directory tells an agent nothing. This lays down the helpers, a
+ * README to write the intent into, a placeholder entry script and a flow
+ * diagram, so whatever opens the folder next can see the shape of the thing
+ * before a line of it exists.
+ *
+ * Existing files are NEVER overwritten (bar the helpers, which are ours and get
+ * rewritten before every run anyway), so calling it on a built project is safe.
+ */
+export function createProject(name, root) {
+  const slug = safeSlug(name);
+  const dir = path.join(workspaceRoot(root), SCRIPTS_DIR, slug);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    return { ok: false, error: `Could not make the folder: ${err.message}` };
+  }
+  writeHelpers(dir);
+  const starters = [
+    ['README.md', STARTER_README(slug)],
+    ['main.py', STARTER_MAIN(slug)],
+    ['flow.md', STARTER_FLOW(slug)],
+    ['.env', '# KEY=value - one per line. Values stay on this computer.\n'],
+  ];
+  for (const [name_, body] of starters) {
+    const f = path.join(dir, name_);
+    if (fs.existsSync(f)) continue;
+    try { fs.writeFileSync(f, body, 'utf8'); } catch { /* best effort */ }
+  }
+  return { ok: true, job: slug };
+}
+
+// ---- chat sessions, stored WITH the project they belong to -----------------
+//
+// On this computer, never on Atlas: a build conversation is as private as the
+// script it produced. Living inside the project folder means a session cannot
+// outlive what it was about, and deleting the project takes its history too.
+const CHATS_DIR = '.chats';
+const chatsDir = (job, root) => path.join(workspaceRoot(root), SCRIPTS_DIR, safeSlug(job), CHATS_DIR);
+const chatFile = (job, id, root) => path.join(chatsDir(job, root), `${safeSlug(id)}.json`);
+
+/** Every build conversation for one project, newest first. */
+export function listChats(job, root) {
+  let names = [];
+  try {
+    names = fs.readdirSync(chatsDir(job, root)).filter((n) => n.endsWith('.json'));
+  } catch { return []; }
+  const out = [];
+  for (const n of names) {
+    let data;
+    try { data = JSON.parse(fs.readFileSync(path.join(chatsDir(job, root), n), 'utf8')); } catch { continue; }
+    const msgs = data.messages || [];
+    const first = (msgs.find((m) => m.role === 'user') || {}).text || '';
+    out.push({
+      id: n.replace(/\.json$/, ''),
+      title: (first || 'New conversation').trim().slice(0, 80),
+      updated_at: data.updated_at || 0,
+      messages: msgs.length,
+    });
+  }
+  out.sort((a, b) => b.updated_at - a.updated_at);
+  return out.slice(0, 50);
+}
+
+/** One conversation, in full. */
+export function readChat(job, id, root) {
+  try {
+    const data = JSON.parse(fs.readFileSync(chatFile(job, id, root), 'utf8'));
+    return { ok: true, id: safeSlug(id), messages: data.messages || [] };
+  } catch {
+    return { ok: false, error: 'That conversation is not on this computer.' };
+  }
+}
+
+/**
+ * Forget one conversation.
+ *
+ * The owner's to delete, like everything else here: their machine, their
+ * history. safeSlug keeps the id inside the project's own folder, so a crafted
+ * id cannot reach a file that is not a conversation.
+ */
+export function deleteChat(job, id, root) {
+  try {
+    fs.unlinkSync(chatFile(job, id, root));
+    return { ok: true, deleted: true };
+  } catch (err) {
+    if (err.code === 'ENOENT') return { ok: true, deleted: false };
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Add one turn to a conversation, creating it if this is the first.
+ * Best-effort: a history that cannot be written must never stop the build.
+ */
+export function appendChat(job, id, role, text, root) {
+  if (!text) return;
+  try { fs.mkdirSync(chatsDir(job, root), { recursive: true }); } catch { return; }
+  const f = chatFile(job, id, root);
+  let data = { messages: [] };
+  try { data = JSON.parse(fs.readFileSync(f, 'utf8')); } catch { /* first turn */ }
+  if (!Array.isArray(data.messages)) data.messages = [];
+  data.messages.push({ role, text, at: Date.now() / 1000 });
+  data.updated_at = Date.now() / 1000;
+  try { fs.writeFileSync(f, JSON.stringify(data), 'utf8'); } catch { /* best effort */ }
+}