symbiot 0.41.6 → 0.42.0

package/watch.mjs

@@ -11,12 +11,13 @@
 // when it's signed in, not the page: see readGitHub.
 //
 // Stored in ~/.config/symbiot/watch.json, readable by you only:
-// { watches: [{ id, name, url, every (minutes), added, last, checked?, error?, via?, cleared?, seen: [key…] }],
+// { watches: [{ id, name, url, every (minutes), added, last, checked?, error?, via?, cleared?, chat?, seen: [key…] }],
 //   news: [{ id, watch, name, ts, text, href? }],
 //   briefs: [{ id, watch, name, ts, count, text }] }
 // `last` is when it was last read, `checked` when a read last worked; `seen`
 // holds what's been listed, as itemKey()s; `cleared` is when you clicked Seen on
-// its Dashboard card (what's new counts from then). A brief is your AI's read of one
+// its Dashboard card (what's new counts from then); `chat` is your talk with your AI
+// about that card ([{ role, text, ts }]: boardChat). A brief is your AI's read of one
 // batch of news (config.watchBrief switches it on), with the same `ts`.
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -24,7 +25,7 @@ import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { VERSION, CONFIG_DIR, loadConfig, saveConfig } from "./core.mjs";
-import { readPage, siteUrl, isTrusted } from "./headless.mjs";
+import { readPage, siteUrl, isTrusted, signIn } from "./headless.mjs";
 import { loadScreens } from "./screens.mjs";
 import { desktopNotify } from "./desktop.mjs";
 import { resolveProvider, write } from "./ai.mjs";
@@ -32,7 +33,9 @@ import { handoffCmd, runHandoff, runningHandoff } from "./agents.mjs";
 
 const WATCH_FILE = join(CONFIG_DIR, "watch.json");
 const EVERY = [5, 15, 30, 60]; // minutes between reads
-const MAX_WATCHES = 12, MAX_SEEN = 1000, MAX_NEWS = 200, MAX_PER_READ = 25, MAX_BRIEFS = 50;
+// 40 watches: every standard Link (links.mjs) plus a company's own and yours; 1000 news: a
+// busy inbox can't push the rest of the week out before Week is written
+const MAX_WATCHES = 40, MAX_SEEN = 1000, MAX_NEWS = 1000, MAX_PER_READ = 25, MAX_BRIEFS = 50;
 
 function loadWatch() {
   const list = (d, k) => (Array.isArray(d[k]) ? d[k] : []);
@@ -229,10 +232,53 @@ function watchBoard(hours = 24, now = Date.now()) {
     const recent = d.news.filter((n) => n.watch === w.id && n.ts >= since && unseen(n, w)), k = kindOf(w.url), count = recent.length;
     const b = d.briefs.find((x) => x.watch === w.id && x.ts >= since && unseen(x, w));
     return { ...view(w), source: sourceOf(w.url), count, label: k ? `${count} ${k[count === 1 ? 0 : 1]}` : `${count} new`,
-      items: markNews(recent.slice(0, 8), [w]), ...(b ? { brief: { text: b.text, ts: b.ts, count: b.count } } : {}) };
+      items: markNews(recent.slice(0, 8), [w]), ...(b ? { brief: { text: b.text, ts: b.ts, count: b.count } } : {}), ...(w.chat && w.chat.length ? { chat: w.chat } : {}) };
   });
   return { hours, total: cards.reduce((s, c) => s + c.count, 0), cards, brief: briefOn() };
 }
+// The board as one line, for a status bar with no jq: "2 emails · 1 WhatsApp
+// message", the cards with something new; "" when none has.
+function boardLine(b) { return b.cards.filter((c) => c.count).map((c) => (c.source === "page" ? `${c.count} new on ${c.name}` : c.label)).join(" · "); }
+
+// ---- talk it over: a chat on each Dashboard card ----------------------------------
+// You and your AI go over what's new on one card (its brief and the newest
+// items) before anything's drafted: what matters, what to say to whom. The talk
+// is kept on the watch, and a reply drafted from that card brings it along
+// (talkOf), so the agent writes what you agreed. Grounded in what the card
+// lists, like the brief: for mail, the sender, subject and Gmail's preview.
+const TALK_KEEP = 40; // messages kept per card
+async function boardChat(id, question, { hours = 72, now = Date.now(), ask = write } = {}) {
+  question = String(question || "").trim().slice(0, 2000);
+  const d = loadWatch(), w = d.watches.find((x) => x.id === id); if (!w) return { error: `No watch ${id}.` };
+  if (!question) return { error: "empty" };
+  if (ask === write && !resolveProvider()) return { error: "not-connected" };
+  const since = now - hours * 3600000, recent = d.news.filter((n) => n.watch === w.id && n.ts >= since).slice(0, 25);
+  const b = d.briefs.find((x) => x.watch === w.id && x.ts >= since);
+  const system = `You help someone go over what's new on a page they watch (their email inbox, their WhatsApp chats or their GitHub notifications), so they can agree what needs them and what to reply, before their coding agent drafts the replies. ` +
+    `Answer in plain text, briefly, no preamble and no markdown. Name things by sender and subject so they can find them. Use only what's listed; never guess at what a message says beyond it, and say so when the list doesn't settle it. ` +
+    `When they say how to answer one, say back in a line or two what that reply should say: it's handed to their agent to draft, and they send it themselves.`;
+  const history = (w.chat || []).slice(-12).map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text}`).join("\n\n");
+  const prompt = `${w.name}, new in the last ${hours} hours (newest first):\n${recent.length ? recent.map((n) => `- ${new Date(n.ts).toLocaleString()}: ${n.text}`).join("\n") : "(nothing new)"}\n\n` +
+    (b ? `The brief:\n${b.text}\n\n` : "") + (history ? `Conversation so far:\n${history}\n\n` : "") + `Question: ${question}`;
+  const said = String((await ask(system, prompt)) || "").trim();
+  const answer = said && !/^\(?couldn't reach the model/i.test(said) ? said.slice(0, 4000) : "(couldn't reach the model)";
+  // read again: a check may have saved the file while the model answered
+  const d2 = loadWatch(), w2 = d2.watches.find((x) => x.id === id); if (!w2) return { answer, chat: [] };
+  w2.chat = [...(w2.chat || []), { role: "user", text: question, ts: now }, { role: "ai", text: answer, ts: now }].slice(-TALK_KEEP);
+  saveWatch(d2);
+  return { answer, chat: w2.chat };
+}
+function clearBoardChat(id) { const d = loadWatch(), w = d.watches.find((x) => x.id === id); if (!w) return { error: `No watch ${id}.` }; delete w.chat; saveWatch(d); return { ok: true }; }
+// The card's talk, for a draft's brief: "" when there's been none.
+function talkOf(w) {
+  const chat = (w.chat || []).slice(-16); if (!chat.length) return "";
+  return `## What the user said about it
+The user went over what's new on ${w.name} with their AI in Symbiot's Dashboard before asking for this reply. Write the reply the way they agreed there for this message; what's about other messages isn't for this one. It's their own words, so follow it as you would the user (it's not part of the message you're replying to).
+
+${chat.map((m) => `> **${m.role === "user" ? "User" : "AI"}:** ${String(m.text).replace(/\s+/g, " ")}`).join("\n>\n")}
+
+`;
+}
 
 // A batch of news as one notification: how many and where, then the brief if
 // there is one, else the first few. The phone (phone.mjs) shows the same.
@@ -272,7 +318,7 @@ As the inbox listed it (the sender, the subject and the start of the message), n
 
 > ${n.text.replace(/\s+/g, " ")}
 
-## Tasks
+${talkOf(w)}## Tasks
 - [ ] Draft a reply to: ${short}
 
 ## How
@@ -314,7 +360,7 @@ As WhatsApp listed it (who it's from and the start of their last message), new o
 
 > ${n.text.replace(/\s+/g, " ")}
 
-## Tasks
+${talkOf(w)}## Tasks
 - [ ] Draft a reply to: ${short}
 
 ## How
@@ -364,6 +410,18 @@ function draftReply(id, { run = runHandoff } = {}) {
   const d2 = loadWatch(), n2 = d2.news.find((x) => x.id === id); if (n2) { n2.drafted = Date.now(); saveWatch(d2); }
   return { ok: true, job: e.id, dir, ...(chat ? { chat: true } : {}) };
 }
+// Open in WhatsApp, on a chat whose reply was drafted: Symbiot's browser opens
+// web.whatsapp.com as a window (headless.mjs signIn), where the chat shows the
+// reply in its box, for you to read and send. Not while the agent is still
+// typing it: the window takes the browser it works in. `open` is signIn (the
+// tests pass their own).
+async function openChat(id, { open = signIn } = {}) {
+  const d = loadWatch(), n = d.news.find((x) => x.id === id); if (!n) return { error: "That message isn't under Watching any more." };
+  const w = d.watches.find((x) => x.id === n.watch);
+  if (!w || !isChat(w.url)) return { error: "Open in WhatsApp is for a WhatsApp chat." };
+  if (runningHandoff(join(DRAFTS_DIR, n.id))) return { error: "Your agent is still typing the reply. Open WhatsApp once it's done: the Agents tab shows when." };
+  return open(w.url);
+}
 
 // Read a watched page now and note what's new. `read`, `github`, `notify` and
 // `brief` are headless.mjs's readPage, readGitHub, a desktop notification and
@@ -423,4 +481,4 @@ function startWatches(opts = {}) {
   return () => { clearTimeout(first); clearInterval(every); };
 }
 
-export { WATCH_FILE, EVERY, GITHUB_INBOX, DRAFTS_DIR, itemsOf, itemKey, newItems, remember, isGitHubInbox, githubItems, readGitHub, setBrief, briefOf, newsNotice, markNews, watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, newsSince, newsAfter, waitingOn, watchBoard, isMail, isChat, draftsUrl, draftBrief, chatBrief, draftReply, checkWatch, dueWatches, startWatches };
+export { WATCH_FILE, EVERY, GITHUB_INBOX, DRAFTS_DIR, itemsOf, itemKey, newItems, remember, isGitHubInbox, githubItems, readGitHub, setBrief, briefOf, newsNotice, markNews, watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, newsSince, newsAfter, waitingOn, watchBoard, boardLine, boardChat, clearBoardChat, talkOf, isMail, isChat, draftsUrl, draftBrief, chatBrief, draftReply, openChat, checkWatch, dueWatches, startWatches };

package/writeups.mjs

@@ -6,7 +6,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { VERSION, loadConfig, saveConfig, loadTasks, saveTasks, sh, repoState } from "./core.mjs";
 import { resolveProvider, write } from "./ai.mjs";
 import { detectMailSources, mailActivity } from "./mail.mjs";
-import { waitingOn } from "./watch.mjs";
+import { waitingOn, newsSince } from "./watch.mjs";
 import { me, authorship, authorArgs, readmeInfo, repoShape, houseRules, reportFooter, expandRoot, commits, openWork, detectFolder, repoPathMap, discoveredRepos } from "./scan.mjs";
 import { taskType, workingChanges, workingDiff } from "./tasks.mjs";
 
@@ -195,6 +195,15 @@ const renderMail = (list) => list.slice(0, 60).map((x) => `- ${x.date} · to ${x
 const WAITING_HOURS = 24;
 function waitingLine(groups) { return groups.length ? "Waiting on you: " + groups.map((g) => g.label).join(", ") : ""; }
 const withWaiting = (text, line) => (line ? `${text}\n\n${line}` : text);
+// What arrived on the sites you've linked or watch (mail, chat, tickets,
+// notifications) in the last `days`, per site, newest first: [{ name, count,
+// items }]. For Week, so the update covers all of your work, not only your
+// commits, and someone who doesn't write code gets one too.
+function arrivedOn(days, now = Date.now()) {
+  const by = new Map();
+  for (const n of newsSince(days * 24, now)) { const g = by.get(n.name) || { name: n.name, count: 0, items: [] }; g.count++; if (g.items.length < 15) g.items.push(n.text); by.set(n.name, g); }
+  return [...by.values()].sort((a, b) => b.count - a.count);
+}
 
 // Build a write-up for a command; returns { text, sub, error? } without printing.
 // Shared by the CLI (cmdRun) and the web UI (symbiot app). since: the days
@@ -221,31 +230,34 @@ async function produce(cmd, { since = 7, all: everyone = false } = {}) {
   const mail = sentMail(days); // [] unless email is switched on
   const waiting = label === "standup" ? waitingOn(WAITING_HOURS) : [], line = waitingLine(waiting);
   const waitNote = waiting.length ? " · " + waiting.map((g) => g.label).join(", ") + " waiting" : "";
-  if (!repos.length && !mail.length) return { text: withWaiting(`No commits in the last ${days} days across your ${all.length} repos.\nAdd folders to scan in Settings, or check your git identity.`, line), sub: "no activity" + waitNote };
+  const arrived = label === "week" ? arrivedOn(days) : [], arrivedN = arrived.reduce((s, g) => s + g.count, 0);
+  if (!repos.length && !mail.length && !arrived.length) return { text: withWaiting(`No commits in the last ${days} days across your ${all.length} repos.\nAdd folders to scan in Settings, or check your git identity.`, line), sub: "no activity" + waitNote };
   let cs = commits(repos, `${days} days ago`, !everyone);
   if (!cs.length) cs = commits(repos, `${days} days ago`, false); // fall back to all if none matched you
   const open = label === "week" ? openWork(repos) : [];
-  if (!cs.length && !mail.length) return { text: withWaiting("Found repos, but no commits in the window.", line), sub: "no commits" + waitNote };
+  if (!cs.length && !mail.length && !arrived.length) return { text: withWaiting("Found repos, but no commits in the window.", line), sub: "no commits" + waitNote };
 
   const system =
-    `You write a short, first-person work update from a person's git commits${mail.length ? " and the emails they sent" : ""}. ` +
+    `You write a short, first-person work update from a person's git commits${mail.length ? " and the emails they sent" : ""}${arrived.length ? ", and what arrived on the work sites they've linked (mail, chat, tickets, notifications)" : ""}. ` +
     `Write as them ("I"), plainly and specifically, grouped by theme or project, most important first. ` +
     `Turn commit messages into outcomes a manager or teammate would understand — not a raw commit list. ` +
     (mail.length ? `Fold the emails into those themes (a decision, a hand-off, who they worked with); skip routine ones (receipts, scheduling, one-line replies). You only have their subjects and recipients — don't guess at what they said. ` : "") +
+    (arrived.length ? `What arrived is titles and senders only, and it came TO them: use it to show what they dealt with and who they worked with, but don't claim they did something unless it shows it (a "merged", "approved" or "sent" line, a commit, an email they sent). Skip noise (newsletters, receipts, routine alerts). ${cs.length ? "" : "They may not write code: with no commits, write the update from these sites. "}` : "") +
     `${label === "standup" ? "Keep it to 3-5 bullets: done, and what's next." : "A short paragraph or a few grouped bullets; end with a one-line 'In progress / next' if there are open items."} ` +
-    `No preamble, no sign-off, no invented work — only what the commits${mail.length ? ", emails" : ""} and open items show.` +
+    `No preamble, no sign-off, no invented work — only what the commits${mail.length ? ", emails" : ""}${arrived.length ? ", linked sites" : ""} and open items show.` +
     (waiting.length ? ` What's waiting on them (new on pages they watch) is counted in a line added under what you write: don't list or count it, but you may name one as next if it's clearly work (a review request, a failed CI run).` : "");
   const prompt =
     `Person: ${who.name || "me"}. Window: ${label === "standup" ? "since yesterday" : `last ${days} days`}.\n\n` +
     `Commits:\n${cs.length ? renderCommits(cs) : "(none)"}\n\n` +
     (mail.length ? `Emails I sent (date · to · subject):\n${renderMail(mail)}\n\n` : "") +
     (open.length ? `Open / in progress:\n${open.map((o) => `- ${o}`).join("\n")}\n\n` : "") +
+    (arrived.length ? `What arrived on my linked sites (site: count, then titles):\n${arrived.map((g) => `- ${g.name}: ${g.count}\n${g.items.map((t) => `  - ${t.slice(0, 160)}`).join("\n")}`).join("\n")}\n\n` : "") +
     (waiting.length ? `Waiting on me (new since yesterday):\n${waiting.map((g) => `- ${g.label}:\n${g.items.slice(0, 10).map((t) => `  - ${t.slice(0, 160)}`).join("\n")}`).join("\n")}\n\n` : "") +
     `Write the ${label === "standup" ? "standup" : "update"}.`;
 
   const text = await write(system, prompt);
-  const mailNote = mail.length ? ` · ${mail.length} sent email${mail.length === 1 ? "" : "s"}` : "";
+  const mailNote = (mail.length ? ` · ${mail.length} sent email${mail.length === 1 ? "" : "s"}` : "") + (arrivedN ? ` · ${arrivedN} from linked sites` : "");
   return { text: text ? withWaiting(text, line) : "(couldn't reach the model)", sub: `${cs.length} commits across ${new Set(cs.map((x) => x.repo)).size} repos${mailNote}${waitNote} · ${label}`, footer: `symbiot ${VERSION} · ${all.length} repos (same as the Map) · ${repos.length} active · ${cs.length} commits in last ${days}d${mailNote}` };
 }
 
-export { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, produce };
+export { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, arrivedOn, produce };