codeply-cli 0.5.6 → 0.6.0

package/lib/bots.js

@@ -56,11 +56,11 @@ const TONES = {
 /** What a bot must ask the user before doing. Each maps to engine tools. */
 const APPROVALS = {
   edit_files: { label: 'Editing files', tools: ['write_file', 'edit_file', 'apply_patch', 'fetch_image'] },
-  run_commands: { label: 'Running commands', tools: ['run'] },
-  send: { label: 'Sending anything (email, Slack)', tools: ['gmail_send', 'slack_post_message'] },
+  run_commands: { label: 'Running commands and using your computer', tools: ['run', 'use_computer'] },
+  send: { label: 'Sending anything (email, Slack)', tools: ['gmail_send', 'slack_post_message', 'bot_email_send'] },
   publish: { label: 'Deploying or publishing', tools: ['vercel_deploy', 'github_create_repo', 'vercel_api', 'publish_deploy', 'publish_github'] },
   databases: { label: 'Changing databases or cloud projects', tools: ['supabase_create_project', 'supabase_delete_project', 'supabase_api', 'supabase_sql', 'supabase_setup', 'supabase_schema'] },
-  calendar: { label: 'Adding to your calendar', tools: ['calendar_add'] },
+  calendar: { label: 'Adding to your calendar', tools: ['calendar_add', 'calendar_update'] },
 };
 const ALL_APPROVALS = Object.keys(APPROVALS);
 // The categories bots were saved with before `calendar` existed. A bot saved
@@ -97,6 +97,54 @@ function normalizeAlwaysOn(a) {
   };
 }
 
+// Autonomy: how much a bot may do. The user picks one of three levels:
+//   none  Level 1: information and suggestions only. It never edits, runs,
+//         sends, publishes or books anything, watched or not; it drafts and
+//         tells the user what it would do
+//   ask   Level 2: it does the work and asks before each action outside its
+//         approval boundary (as before)
+//   hold  Level 2, softer: outward actions (send, publish, databases, calendar)
+//         wait holdMinutes in the outbox, where the user can cancel them from
+//         the phone or Crew; then go
+//   full  Level 3: the categories in `allow` run at once
+// Deleting things, anything flagged dangerous and anything a third party asked
+// for always wait for the user, at every level.
+const AUTONOMY = { none: 'Just suggest, never act', ask: 'Ask me first', hold: 'Do it after a wait I can cancel', full: 'Just do it' };
+function normalizeAutonomy(a) {
+  a = a && typeof a === 'object' ? a : {};
+  const n = (v, d, lo, hi) => { const x = Math.round(Number(v)); return Number.isFinite(x) ? Math.max(lo, Math.min(hi, x)) : d; };
+  const b = a.budgets && typeof a.budgets === 'object' ? a.budgets : {};
+  return {
+    level: AUTONOMY[a.level] ? a.level : 'ask',
+    holdMinutes: n(a.holdMinutes, 10, 1, 240),
+    allow: (Array.isArray(a.allow) ? a.allow : ['edit_files', 'run_commands']).filter((k) => APPROVALS[k]),
+    // Per day, per bot. 0 means never on its own.
+    budgets: { runs: n(b.runs, 10, 0, 200), emails: n(b.emails, 10, 0, 200), posts: n(b.posts, 3, 0, 100), deploys: n(b.deploys, 3, 0, 50) },
+  };
+}
+
+// On calls (the call helper in life-desktop.js): how the bot steps in when the user hands a call over.
+const EXCUSE_STYLES = { friendly: 'Warm and casual', formal: 'Polite and formal', brief: 'Short and to the point', playful: 'Light and a bit funny' };
+function normalizeCallStyle(c) {
+  c = c && typeof c === 'object' ? c : {};
+  return {
+    style: EXCUSE_STYLES[c.style] ? c.style : 'friendly',
+    // Excuses the user approved. The bot picks one that fits; with none it says the user had to step away.
+    excuses: (Array.isArray(c.excuses) ? c.excuses : []).filter((x) => typeof x === 'string' && x.trim()).map((x) => clip(x.trim(), 200)).slice(0, 8),
+  };
+}
+
+// The bot's own email address (bot-mail on Codeply's server, sent through Resend).
+const BOT_ADDRESS = /^[a-z0-9][a-z0-9._-]{0,40}@[a-z0-9.-]+\.[a-z]{2,}$/i;
+function normalizeEmail(e) {
+  e = e && typeof e === 'object' ? e : {};
+  const address = BOT_ADDRESS.test(String(e.address || '')) ? String(e.address).toLowerCase() : '';
+  return { address, on: !!(address && e.on !== false) };
+}
+
+const lifeLib = () => require('./life.js');
+const brainLib = () => require('./brain.js');
+
 // Kept in sync with bot-avatar.js (the renderer). The engine only validates.
 const AVATAR_KEYS = {
   shape: ['burst9', 'burst7', 'burst12', 'flower', 'cloud', 'star', 'squircle', 'pebble', 'drop'],
@@ -239,6 +287,13 @@ function normalizeBot(input, existing) {
     // The voice it speaks with on calls (a Deepgram, Edge or Kokoro voice id; '' = pick one).
     voice: typeof b.voice === 'string' && /^[\w.-]{0,80}$/.test(b.voice) ? b.voice : '',
     alwaysOn: normalizeAlwaysOn(b.alwaysOn),
+    // What it may read of the user's life context (life.js), and which nudges it sends.
+    life: lifeLib().normalizeLife(b.life),
+    autonomy: normalizeAutonomy(b.autonomy),
+    callStyle: normalizeCallStyle(b.callStyle),
+    email: normalizeEmail(b.email),
+    // The jobs it takes handoffs for (brain.js DOMAINS); empty = read from its specialty.
+    handles: (Array.isArray(b.handles) ? [...new Set(b.handles)] : []).filter((d) => brainLib().DOMAINS[d]).slice(0, 6),
     memory: cleanMemory(b.memory),
     // Experience (learned on the job, see reflectOnRun): lessons, playbooks, tool tips, open threads.
     lessons: cleanLessons(b.lessons),
@@ -383,6 +438,10 @@ async function learnFromTurn(bot, userText, replyText, chatFn) {
     const user = clip(userText, 3000);
     if (!user) return { added: [] };
     const known = (bot.memory || []).slice(-30).map((m) => `- ${m.fact}`).join('\n') || '(nothing yet)';
+    // Plans the user mentions go to the shared life context (life.js), from the same model call.
+    const life = lifeLib().available() && lifeLib().allowedFor(bot).has('plans') ? lifeLib() : null;
+    // And what is worth knowing in every app goes to the shared brain (brain.js), from the same call too.
+    const brain = brainLib().available() ? brainLib() : null;
     const prompt = `You keep the long-term memory of an assistant called ${bot.name}${bot.specialty ? ` (${bot.specialty})` : ''}.
 From the exchange below, pick at most ${MAX_FACTS_PER_TURN} durable things worth remembering for future conversations: the user's preferences, decisions, standing instructions, facts about them or their project, or feedback on how ${bot.name} should work.
 Skip anything one-off, temporary, obvious, or already known. Never store passwords, keys or other secrets. Each item is one short sentence about the user or the work, written in the third person ("The user prefers ...").
@@ -393,18 +452,24 @@ ${known}
 User: ${user}
 
 ${bot.name}: ${clip(replyText, 3000) || '(no reply)'}
-
-Respond with ONLY a JSON object {"facts": ["..."]}. Use an empty list when nothing is worth keeping.`;
+${life ? `\n${life.plansAsk()}\n` : ''}${brain ? `\n${brain.observationsAsk()}\n` : ''}
+Respond with ONLY a JSON object {"facts": ["..."]${life ? ', "plans": []' : ''}${brain ? ', "observations": []' : ''}}. Use an empty list when nothing is worth keeping.`;
     const r = await chatFn([{ role: 'user', content: prompt }]);
     if (!r || !r.success || !r.json) return { added: [] };
+    if (life && Array.isArray(r.json.plans) && r.json.plans.length) { try { life.notePlans(r.json.plans, { source: 'chat', botId: bot.id }); } catch {} }
+    let brainNotes = [];
+    if (brain && Array.isArray(r.json.observations) && r.json.observations.length) {
+      // The product (Crew or Craft) comes from the running one (telemetry.js).
+      try { brainNotes = brain.noteObservations(r.json.observations, { botId: bot.id, botName: bot.name }); } catch {}
+    }
     const facts = (Array.isArray(r.json.facts) ? r.json.facts : [])
       .filter((f) => typeof f === 'string')
       .map((f) => f.trim())
       .filter((f) => f.length >= 4 && !/(api[_ -]?key|password|secret|token)\s*[:=]/i.test(f))
       .filter((f) => !(bot.memory || []).some((m) => factKey(m.fact) === factKey(f)))
       .slice(0, MAX_FACTS_PER_TURN);
-    if (!facts.length) return { added: [] };
-    return addMemory(bot.id, facts);
+    if (!facts.length) return { added: [], brain: brainNotes };
+    return { ...addMemory(bot.id, facts), brain: brainNotes };
   } catch {
     return { added: [] };
   }
@@ -562,7 +627,12 @@ const STOP = new Set('the and for with that this from what when where which your
 function terms(text) {
   return [...new Set(String(text || '').toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').split(/\s+/)
     .filter((w) => w.length >= 3 && !STOP.has(w))
-    .map((w) => (w.length > 4 ? w.replace(/(ing|es|s)$/, '') : w)))];
+    .map((w) => {
+      if (w.length > 4 && w.endsWith('s') && !w.endsWith('ss')) w = w.slice(0, -1);
+      if (w.length > 5 && w.endsWith('ing')) w = w.slice(0, -3);
+      if (w.length > 4 && w.endsWith('e')) w = w.slice(0, -1);
+      return w;
+    }))];
 }
 
 /** The playbooks that fit a request best (keyword overlap), at most `n`, best first. */
@@ -659,6 +729,11 @@ async function reflectOnRun(bot, run, chatFn) {
       resolved: j.resolved,
     };
     const { added } = addExperience(bot.id, reflection);
+    // The same lessons, shared with the other bots through the brain. They see
+    // one only when it fits their request, labelled as a teammate's experience.
+    if (added && added.lessons && added.lessons.length) {
+      try { brainLib().shareLessons(added.lessons, { botId: bot.id, botName: fresh.name, domain: brainLib().botDomains(fresh)[0] || '' }); } catch {}
+    }
     return { outcome, added };
   } catch {
     return { added: null, skipped: 'failed' };
@@ -668,6 +743,9 @@ async function reflectOnRun(bot, run, chatFn) {
 // ─── Prompts ────────────────────────────────────────────────────────────────
 
 function approvalLine(bot) {
+  if (normalizeAutonomy(bot.autonomy).level === 'none') {
+    return 'You are set to suggest only (the user chose this). Never edit files, run commands, send, post, publish, book or change anything, even when asked in this chat: Craft refuses those actions for you. Read, look things up, think, then give your suggestion or a ready-to-use draft and say what you would do.';
+  }
   const must = (bot.approval || []).map((k) => APPROVALS[k] && APPROVALS[k].label.toLowerCase()).filter(Boolean);
   if (!must.length) return 'You may act without asking first. Still never do anything irreversible the user did not ask for.';
   return `Always get the user's approval before: ${must.join('; ')}. Craft enforces this too. Do reversible, read-only work (reading, searching, thinking) without asking.`;
@@ -691,7 +769,7 @@ You can reach the user on their phone with reach_me, and watch their inbox with
 - Urgent or time critical, or they asked for a call: reach_me with how=call (the phone rings and you speak).
 - Anything else worth their attention: how=text (a notification).
 - "Tell me / call me when X emails me": watch_email with from=X and how=call or text. Do not say you cannot run in the background.
-- A reminder at a time: reach_me with at set to that time.
+- A reminder at a time: reach_me with at set to that time. It also goes on their Google Calendar by itself (when connected), so never add it again with calendar_add, and never tell them it is not on the calendar.
 - "Have Shella call me": reach_me with bot set to that bot's name, so the call comes from them.`;
 const PHONE_FORMAT = `To reach the phone or watch for an email, write:
 <codeply:reach_me>
@@ -705,6 +783,14 @@ const PHONE_FORMAT = `To reach the phone or watch for an email, write:
 <how>call</how>
 </codeply:watch_email>`;
 
+const LIFE_RULES = `THE USER'S LIFE CONTEXT
+All the user's bots share one picture of their life: calendar, email, calls, plans, projects, what is on screen, the important bits heard around them. Look things up with life_context (about = now, today, tomorrow, week, person, calls, email, activity, heard, plans, projects, slack, tasks, health, or a query to search) before saying you do not know what the user has on, who someone is, or what happened. It is private: use it to help the user, never pass it on to anyone else.`;
+const LIFE_FORMAT = `To look something up, write:
+<codeply:life_context>
+<about>person</about>
+<query>Sara</query>
+</codeply:life_context>`;
+
 const VERIFY_RULES = `BEFORE YOU SAY IT IS DONE
 - Base every claim on what your tools actually returned in this run.
 - Check the deliverable exists (the file is written, the message is sent, the command passed) before you say so.
@@ -771,6 +857,20 @@ function buildBotPrompt(bot, o = {}) {
   }
   parts.push(...experienceParts(bot, o.request));
   if (require('./reach.js').available()) parts.push(o.native ? PHONE_RULES : `${PHONE_RULES}\n\n${PHONE_FORMAT}`);
+  const mail = require('./bot-mail.js');
+  if (mail.available() && mail.addressOf(bot.id)) parts.push(mail.RULES(mail.addressOf(bot.id), !!o.native));
+  const L = lifeLib();
+  if (L.available() && o.life !== false) {
+    const allowed = L.allowedFor(bot);
+    if (allowed.size) {
+      let block = '';
+      try { block = L.nowBlock(L.snapshot({ allowed }), { skipEmpty: true }); } catch {}
+      // Said up front, so the bot never promises "I'll list your calls" and then finds out it may not.
+      const shut = L.SOURCE_KEYS.filter((k) => !allowed.has(k)).map((k) => L.SOURCES[k].label.toLowerCase());
+      const limits = shut.length ? `You cannot read: ${shut.join('; ')}. Never offer to check those; if the user wants it, they can allow it in your Life settings in Crew.` : '';
+      parts.push([block, o.native ? LIFE_RULES : `${LIFE_RULES}\n\n${LIFE_FORMAT}`, limits].filter(Boolean).join('\n\n'));
+    }
+  }
   parts.push(VERIFY_RULES);
   if (o.askedBy) {
     parts.push(`DELEGATED TASK\n${o.askedBy} asked you to do one task. You only see that task, not the rest of the conversation. Do it fully with your tools, then reply in this shape:\nSummary: <one sentence with the outcome>\n<the details: findings, what you changed, anything ${o.askedBy} must know or check>`);
@@ -782,9 +882,28 @@ function buildBotPrompt(bot, o = {}) {
       : `You can ask a teammate for help with ask_bot when part of the work is clearly in their domain. Only one bot runs at a time, and you wait for the answer.`;
     parts.push(`TEAM\n${lead}\nTeammates:\n${roster.join('\n')}${o.native ? '' : `\n\n${ASK_BOT_FORMAT}`}`);
   }
+  if (o.canHandOff && roster.length) parts.push(handOffRules(o.team, bot.id, !!o.native));
   return parts.join('\n\n');
 }
 
+/** hand_off: passing work on without waiting (brain.js), for bots and for plain Craft. */
+function handOffRules(team, selfId, native) {
+  const B = brainLib();
+  const who = (team || []).filter((b) => b.id !== selfId).map((b) => `${b.name} (${B.botDomains(b).join(', ') || 'general'})`).join('; ');
+  return `HANDING WORK ON
+When part of a job belongs to another bot's domain and you do not need the answer to finish yours, pass it on with hand_off and carry on: an email asking for a meeting goes to the calendar bot, a follow-up date to the reminders bot. Send only what they need (the intent, the facts with exact names, addresses, dates and time zones, what is decided), never the whole conversation. Use ask_bot instead when you need their result to continue. Who handles what: ${who}.${native ? '' : `
+
+<codeply:hand_off>
+<to>calendar</to>
+<intent>Mike proposed meeting tomorrow at 5:00 (Asia/Karachi). Check the calendar and the user's preferences, and propose the slot or a better one.</intent>
+<facts>
+From: Mike Chen <mike@example.com>
+Gmail thread: 18c2f0a1b2
+</facts>
+<decision>I drafted a holding reply; not sent.</decision>
+</codeply:hand_off>`}`;
+}
+
 /** The short roster note when the plain Craft agent (no bot chosen) can still ask bots. */
 function teamPrompt(team, o = {}) {
   const roster = rosterLines(team, null);
@@ -792,7 +911,13 @@ function teamPrompt(team, o = {}) {
   const phone = require('./reach.js').available()
     ? `\n\nWhen the user asks a bot to call or text them ("tell Shella to call me"), do it yourself with reach_me and bot set to that bot's name, so it comes from that bot. ${o.native ? '' : PHONE_FORMAT}`
     : '';
-  return `BOTS\nThe user has these bots. When they ask for one by name, or a part of the work is clearly a bot's specialty, you can hand it that part with ask_bot. Only one bot runs at a time, and you wait for its answer.\n${roster.join('\n')}${o.native ? '' : `\n\n${ASK_BOT_FORMAT}`}${phone}`;
+  const handOff = o.canHandOff ? `\n\n${handOffRules(team, null, !!o.native)}` : '';
+  return `BOTS\nThe user has these bots. When they ask for one by name, or a part of the work is clearly a bot's specialty, you can hand it that part with ask_bot. Only one bot runs at a time, and you wait for its answer.\n${roster.join('\n')}${o.native ? '' : `\n\n${ASK_BOT_FORMAT}`}${phone}${handOff}`;
+}
+
+/** Level 1 (suggest only): this bot may not take this action at all, watched or not. */
+function suggestOnly(bot, tool) {
+  return !!bot && normalizeAutonomy(bot.autonomy).level === 'none' && (!!approvalCategory(tool) || tool === 'gmail_draft' || tool === 'add_model');
 }
 
 /** Which approval category a tool falls into, or null. */
@@ -804,6 +929,7 @@ function approvalCategory(tool) {
 /** True when this bot is allowed to do this tool without asking the user. */
 function canSkipApproval(bot, tool) {
   if (!bot) return false;
+  if (normalizeAutonomy(bot.autonomy).level === 'none') return false;
   const cat = approvalCategory(tool);
   return !!cat && !(bot.approval || []).includes(cat);
 }
@@ -1020,6 +1146,7 @@ async function voiceTurn({ bot, team, turns, recentChat, runAgent, route, cwd, s
   const run = runAgent({
     userMessage, history, mode: 'Build', cwd, signal, route, maxSteps, approve, botId: bot.id,
     botPrompt: () => `${buildBotPrompt(bot, { team, request: userMessage })}\n\n${VOICE_RULES}${extra}`,
+    haze: { product: 'mobile', chatId: `call:${bot.id}` },
   });
   let reply = '';
   const steps = []; // the trajectory, for reflectOnRun after the call turn
@@ -1045,23 +1172,23 @@ function runStep(ev) {
 
 /** What the call screen says while a tool runs. */
 const CALL_STEP = {
-  gmail_search: 'Checking your email', gmail_send: 'Sending the email', gmail_draft: 'Saving a draft', drafts_list: 'Looking at your drafts',
-  calendar_list: 'Checking your calendar', calendar_add: 'Adding it to your calendar', web_search: 'Searching the web', image_search: 'Looking for images', reach_me: 'Reaching your phone', watch_email: 'Setting an email alert', web_fetch: 'Reading a page',
+  gmail_search: 'Checking your email', gmail_read: 'Reading the email', gmail_send: 'Sending the email', gmail_draft: 'Saving a draft', drafts_list: 'Looking at your drafts',
+  calendar_list: 'Checking your calendar', calendar_add: 'Adding it to your calendar', calendar_update: 'Changing your calendar', web_search: 'Searching the web', image_search: 'Looking for images', reach_me: 'Reaching your phone', watch_email: 'Setting an email alert', web_fetch: 'Reading a page',
   read_file: 'Reading a file', write_file: 'Writing a file', edit_file: 'Editing a file', apply_patch: 'Editing files', run: 'Running a command',
   search: 'Searching your files', list_dir: 'Looking through files', slack_post_message: 'Posting to Slack', browser_check: 'Checking the page',
-  ask_bot: 'Asking a teammate', todo: 'Planning',
+  ask_bot: 'Asking a teammate', todo: 'Planning', life_context: 'Checking your day', look_at_screen: 'Looking at your screen', use_computer: 'Using your computer', bot_email_send: 'Sending the email',
 };
 const callStepLabel = (name) => CALL_STEP[name] || 'Working on it';
 
 module.exports = {
   VOICE_RULES, VOICE_RULES_NO_TOOLS, spoken, callTurns, voiceTurn, callStepLabel,
   MAX_MEMORY, MAX_DEPTH, ROLES, TONES, APPROVALS, AVATAR_KEYS, TEMPLATES, WATCH_SOURCES, REACH,
-  botsDir, setBotsDir, normalizeBot, normalizeAvatar, normalizeAlwaysOn,
+  botsDir, setBotsDir, normalizeBot, normalizeAvatar, normalizeAlwaysOn, normalizeAutonomy, normalizeCallStyle, normalizeEmail, AUTONOMY, EXCUSE_STYLES,
   listBots, getBot, findBot, createBot, createFromTemplate, updateBot, removeBot,
   mergeMemory, addMemory, forget, clearMemory, learnFromTurn,
   MAX_LESSONS, MAX_PLAYBOOKS, MAX_TOOL_TIPS, MAX_OPEN_THREADS,
   mergeExperience, addExperience, forgetExperience, rankPlaybooks, reflectOnRun, runStep,
-  buildBotPrompt, teamPrompt, approvalCategory, canSkipApproval,
+  buildBotPrompt, teamPrompt, handOffRules, approvalCategory, canSkipApproval, suggestOnly,
   createLock, globalLock, parseResult, delegate, botCard,
   describePrompt, fromDescription,
 };