@chatpanel/events 0.102.0 → 0.104.0

package/note-actions.js

@@ -1,252 +1,21 @@
-// AI writing in a note — what the model is asked, and where its answer lands.
-//
-// A note has three ways to ask a model to write: a NAMED ACTION on the selection or the whole
-// note ("Continue writing", "Summarize", "Turn into tasks", "Improve writing"), an
-// `@command instruction` typed on a line ("@table the G7 by population"), and a `/` palette
-// that offers the actions at the caret. Every client has all three, and each has two halves
-// that must agree: the PROMPT the model receives and the FRAME the output is written into —
-// head, output, tail. Ask for a summary and land it at the caret, or ask for a checklist and
-// replace the whole note with it, and the feature is wrong in a way no prompt fixes.
-//
-// These lived inside the extension's `notes.js` — five thousand lines, DOM-bound — and the
-// desktop was about to type them a second time. Nothing here needs a window: the specs are
-// data, the framing is body + selection in and three strings out, the triggers are text +
-// caret in and a range out. So they are here, and the clients render the menu around them.
-//
-// THE CLIENT STILL OWNS: the model call (through its own streaming path), the editor write,
-// attribution and versioning, and any tools it arms. `NOTE_COMMANDS[].tools` says a command
-// WANTS live data; whether a target can fetch it is the client's to know.
+const h=Object.freeze({continue:Object.freeze({label:"Continue writing",hint:"draft inline from here",system:"You are a writing assistant continuing the user's note. Match their voice, tone and markdown style, and continue naturally from where the text stops. Output ONLY the continuation — no preamble, no repeating prior text.",maxTokens:700,needsSelection:!1}),summarize:Object.freeze({label:"Summarize",hint:"a tight summary",system:"Summarize the text concisely in GitHub-flavored markdown — a few tight bullets or a short paragraph. Output ONLY the summary.",maxTokens:500,needsSelection:!1}),tasks:Object.freeze({label:"Turn into tasks",hint:"selection → checklist",system:'Convert the text into a GitHub-flavored markdown checklist: one actionable item per line as "- [ ] item". Output ONLY the checklist.',maxTokens:700,needsSelection:!0}),improve:Object.freeze({label:"Improve writing",hint:"rewrite clearer",system:"Rewrite the text to be clearer and more concise while preserving its meaning, tone and markdown formatting. Output ONLY the rewritten text.",maxTokens:1e3,needsSelection:!1})}),w=.5,p=Object.freeze(["continue","summarize","tasks","improve"]),x=e=>h[e]?.label||String(e||"");function N(e,n,r=0,s=r){if(!h[e])return{error:"unknown"};const t=String(n??""),a=f(r,0,t.length),l=f(s,a,t.length),i=t.slice(a,l);let c,u,m;if(e==="continue")c=t,u=t+(t&&!/\s$/.test(t)?`
 
-/**
- * The named actions, keyed the way the menus and the `/` palette refer to them.
- *
- * `system` is the whole instruction; the user turn is the target text alone. Every prompt
- * ends in "Output ONLY …" because the answer is written INTO the note — a "Sure! Here is
- * your summary:" preamble would land in the document verbatim.
- */
-export const NOTE_ACTIONS = Object.freeze({
-  continue: Object.freeze({
-    label: 'Continue writing',
-    hint: 'draft inline from here',
-    system: "You are a writing assistant continuing the user's note. Match their voice, tone and markdown style, and continue naturally from where the text stops. Output ONLY the continuation — no preamble, no repeating prior text.",
-    maxTokens: 700,
-    needsSelection: false,
-  }),
-  summarize: Object.freeze({
-    label: 'Summarize',
-    hint: 'a tight summary',
-    system: 'Summarize the text concisely in GitHub-flavored markdown — a few tight bullets or a short paragraph. Output ONLY the summary.',
-    maxTokens: 500,
-    needsSelection: false,
-  }),
-  tasks: Object.freeze({
-    label: 'Turn into tasks',
-    hint: 'selection → checklist',
-    system: 'Convert the text into a GitHub-flavored markdown checklist: one actionable item per line as "- [ ] item". Output ONLY the checklist.',
-    maxTokens: 700,
-    needsSelection: true,
-  }),
-  improve: Object.freeze({
-    label: 'Improve writing',
-    hint: 'rewrite clearer',
-    system: 'Rewrite the text to be clearer and more concise while preserving its meaning, tone and markdown formatting. Output ONLY the rewritten text.',
-    maxTokens: 1000,
-    needsSelection: false,
-  }),
-});
+`:""),m="";else if(e==="summarize")c=i||t,u=`${t.replace(/\s+$/,"")}
 
-/** The sampling every action uses. Low enough to stay on-task, high enough to write prose. */
-export const NOTE_ACTION_TEMPERATURE = 0.5;
+## Summary
 
-/** The order the `/` palette and the Agent menu list them in. */
-export const NOTE_ACTION_ORDER = Object.freeze(['continue', 'summarize', 'tasks', 'improve']);
+`,m="";else if(e==="tasks"){if(!i.trim())return{error:"select"};c=i,u=t.slice(0,a),m=t.slice(l)}else c=i||t,u=i?t.slice(0,a):"",m=i?t.slice(l):"";return c.trim()?{target:c,head:u,tail:m}:{error:"empty"}}const y=Object.freeze({select:"Select some text first",empty:"Nothing to work with yet",unknown:"Unknown action"}),d=Object.freeze([Object.freeze({cmd:"insert",label:"Insert",hint:"generate or fetch, then insert",tools:!0,system:"You insert content into the user's note. Follow the instruction. If it needs current, live, or web data, USE the web_search tool to fetch it — never guess or use stale knowledge. Output ONLY the content to insert as clean GitHub-flavored markdown — no preamble, no closing remarks."}),Object.freeze({cmd:"table",label:"Table",hint:"produce a markdown table",tools:!0,system:"Produce the requested data as a GitHub-flavored markdown table. If it needs live/current data, USE the web_search tool. Output ONLY the table."}),Object.freeze({cmd:"list",label:"List",hint:"produce a bullet/task list",tools:!0,system:"Produce the requested content as a GitHub-flavored markdown list (use - [ ] for actionable tasks). Use web_search for live data. Output ONLY the list."}),Object.freeze({cmd:"summarize",label:"Summarize",hint:"summarize a topic",tools:!1,system:"Summarize the requested topic concisely in markdown. Output ONLY the summary."}),Object.freeze({cmd:"translate",label:"Translate",hint:"translate to a language",tools:!1,system:"Translate the requested text to the requested language, preserving markdown. Output ONLY the translation."})]),T=.4,k=1800,b=new RegExp(`@(${d.map(e=>e.cmd).join("|")})\\b[ \\t]*(.*)$`,"i");function S(e,n){const r=String(e??""),s=f(n,0,r.length),o=r.lastIndexOf(`
+`,s-1)+1;let t=r.indexOf(`
+`,s);t<0&&(t=r.length);const l=r.slice(o,t).match(b);if(!l)return null;const i=d.find(u=>u.cmd===l[1].toLowerCase()),c=(l[2]||"").trim();return!i||!c?null:{spec:i,instruction:c,start:o+l.index,end:t}}function E(e,n,r,{hasSelection:s=!1}={}){if(s)return null;const o=String(e??""),t=f(n,0,o.length),a=o.slice(o.lastIndexOf(`
+`,t-1)+1,t),l=g(String(r||"/")),i=a.match(new RegExp(`(?:^|\\s)${l}(\\w*)$`));return i?{word:i[1],start:t-i[1].length,end:t}:null}function z(e,n){const r=String(n||"").trim().toLowerCase(),s=Array.isArray(e)?e:[];return r?s.filter(o=>String(o.key||"").toLowerCase().startsWith(r)||String(o.label||"").toLowerCase().includes(r)):s}function _(e=p){return e.filter(n=>h[n]).map(n=>({key:n,label:h[n].label,hint:h[n].hint}))}const O=4e3;function v(e,n,{title:r="",max:s=O}={}){const o=`${e??""}
+${n??""}`.replace(/\n{3,}/g,`
 
-/** The label for an action key, or the key itself for one this build does not know. */
-export const noteActionLabel = (kind) => NOTE_ACTIONS[kind]?.label || String(kind || '');
+`).trim();if(!o)return"";const t=o.length>s?`${o.slice(0,s)}
+…(note truncated)`:o,a=String(r||"").trim();return`The note I'm editing${a?` (title: "${a}")`:""} is below. Resolve any reference in my instruction — "this meeting", "above", a date, a name, a [[wikilink]] or a URL (a meeting link's #id identifies that exact meeting) — against THIS note, not a guess. If a tool lets you fetch something referenced here by id, use that id.
 
-/**
- * Where an action's output lands.
- *
- * Returns `{ target, head, tail }`: the text the model is given, and what sits before and
- * after its answer in the finished note. Or `{ error }` — one of the two ways an action
- * cannot run — so a client shows the reason rather than sending an empty prompt and reading
- * the model's confusion back into the document.
- *
- *   continue   — the whole note in, the answer appended after a blank line;
- *   summarize  — the selection (or the note) in, a `## Summary` section appended at the end;
- *   tasks      — the selection in, the checklist REPLACES it; needs a selection, because a
- *                checklist of the entire note replacing the entire note is never what was meant;
- *   improve    — the selection in and replaced; with no selection the whole note is rewritten.
- *
- * `error` is 'select' (this action needs a selection) or 'empty' (nothing to work with).
- */
-export function frameNoteAction(kind, body, selStart = 0, selEnd = selStart) {
-  const spec = NOTE_ACTIONS[kind];
-  if (!spec) return { error: 'unknown' };
-  const text = String(body ?? '');
-  const s0 = clamp(selStart, 0, text.length);
-  const s1 = clamp(selEnd, s0, text.length);
-  const sel = text.slice(s0, s1);
+"""
+${t}
+"""`}function A(e,n){const r=String(e??"");return n?`${n}
 
-  let target;
-  let head;
-  let tail;
-  if (kind === 'continue') {
-    target = text;
-    head = text + (text && !/\s$/.test(text) ? '\n\n' : '');
-    tail = '';
-  } else if (kind === 'summarize') {
-    target = sel || text;
-    head = `${text.replace(/\s+$/, '')}\n\n## Summary\n\n`;
-    tail = '';
-  } else if (kind === 'tasks') {
-    if (!sel.trim()) return { error: 'select' };
-    target = sel;
-    head = text.slice(0, s0);
-    tail = text.slice(s1);
-  } else {
-    target = sel || text;
-    head = sel ? text.slice(0, s0) : '';
-    tail = sel ? text.slice(s1) : '';
-  }
-  if (!target.trim()) return { error: 'empty' };
-  return { target, head, tail };
-}
-
-/** What a client should tell the user for each `frameNoteAction` error. */
-export const NOTE_ACTION_ERRORS = Object.freeze({
-  select: 'Select some text first',
-  empty: 'Nothing to work with yet',
-  unknown: 'Unknown action',
-});
-
-/**
- * The `@command instruction` grammar — a line the user writes, and the model replaces.
- *
- * `tools: true` means the command is about live data and wants a web search armed. A target
- * that cannot search (an HTTP model with no tools) still answers; the prompt tells it not to
- * guess, and a client that knows its target cannot fetch may say so.
- */
-export const NOTE_COMMANDS = Object.freeze([
-  Object.freeze({ cmd: 'insert', label: 'Insert', hint: 'generate or fetch, then insert', tools: true, system: 'You insert content into the user\'s note. Follow the instruction. If it needs current, live, or web data, USE the web_search tool to fetch it — never guess or use stale knowledge. Output ONLY the content to insert as clean GitHub-flavored markdown — no preamble, no closing remarks.' }),
-  Object.freeze({ cmd: 'table', label: 'Table', hint: 'produce a markdown table', tools: true, system: 'Produce the requested data as a GitHub-flavored markdown table. If it needs live/current data, USE the web_search tool. Output ONLY the table.' }),
-  Object.freeze({ cmd: 'list', label: 'List', hint: 'produce a bullet/task list', tools: true, system: 'Produce the requested content as a GitHub-flavored markdown list (use - [ ] for actionable tasks). Use web_search for live data. Output ONLY the list.' }),
-  Object.freeze({ cmd: 'summarize', label: 'Summarize', hint: 'summarize a topic', tools: false, system: 'Summarize the requested topic concisely in markdown. Output ONLY the summary.' }),
-  Object.freeze({ cmd: 'translate', label: 'Translate', hint: 'translate to a language', tools: false, system: 'Translate the requested text to the requested language, preserving markdown. Output ONLY the translation.' }),
-]);
-
-/** The sampling a command runs at — tighter than an action, because it is following orders. */
-export const NOTE_COMMAND_TEMPERATURE = 0.4;
-export const NOTE_COMMAND_MAX_TOKENS = 1800;
-
-// Matches `@command …` ANYWHERE on the line, not only at its start, so it works mid-sentence.
-const NOTE_CMD_RE = new RegExp(`@(${NOTE_COMMANDS.map((c) => c.cmd).join('|')})\\b[ \\t]*(.*)$`, 'i');
-
-/**
- * The runnable `@command instruction` on the line the caret is on, or null.
- *
- * Returns `{ spec, instruction, start, end }` where [start, end) is the span to replace —
- * from the `@` to the end of the line, so text BEFORE the command on that line survives.
- * A command with no instruction is not runnable: "@table" alone is the user still typing.
- */
-export function commandLineAt(text, pos) {
-  const v = String(text ?? '');
-  const p = clamp(pos, 0, v.length);
-  const lineStart = v.lastIndexOf('\n', p - 1) + 1;
-  let end = v.indexOf('\n', p);
-  if (end < 0) end = v.length;
-  const line = v.slice(lineStart, end);
-  const m = line.match(NOTE_CMD_RE);
-  if (!m) return null;
-  const spec = NOTE_COMMANDS.find((c) => c.cmd === m[1].toLowerCase());
-  const instruction = (m[2] || '').trim();
-  if (!spec || !instruction) return null;
-  return { spec, instruction, start: lineStart + m.index, end };
-}
-
-/**
- * The `<trigger>word` being typed at the caret — `/` for the palette, `@` for commands and
- * mentions — or null. The trigger must open a token: at the start of the line or after
- * whitespace, so `a/b` and `alex@example.com` never pop a menu. A `#` trigger with a space
- * after it is a markdown heading, which `\w*` already refuses.
- *
- * Returns `{ word, start, end }` where [start, end) is the WORD (not the trigger), which is
- * what a client replaces when an item is picked. `hasSelection` suppresses it: a palette over
- * a selection is a different gesture from a palette at a caret.
- */
-export function triggerQueryAt(text, pos, trigger, { hasSelection = false } = {}) {
-  if (hasSelection) return null;
-  const v = String(text ?? '');
-  const p = clamp(pos, 0, v.length);
-  const line = v.slice(v.lastIndexOf('\n', p - 1) + 1, p);
-  const t = escapeRe(String(trigger || '/'));
-  const m = line.match(new RegExp(`(?:^|\\s)${t}(\\w*)$`));
-  if (!m) return null;
-  return { word: m[1], start: p - m[1].length, end: p };
-}
-
-/**
- * Filter the `/` palette by what has been typed after the slash: a prefix of the key or a
- * substring of the label, case-insensitively. An empty word keeps everything, in order.
- */
-export function filterNoteActions(items, word) {
-  const w = String(word || '').trim().toLowerCase();
-  const list = Array.isArray(items) ? items : [];
-  if (!w) return list;
-  return list.filter((it) => (
-    String(it.key || '').toLowerCase().startsWith(w)
-    || String(it.label || '').toLowerCase().includes(w)
-  ));
-}
-
-/**
- * The palette items for the actions this build lists, in order — `{ key, label, hint }`
- * with no runner, so a client maps keys to its own handlers and drops any it cannot run.
- */
-export function noteActionItems(order = NOTE_ACTION_ORDER) {
-  return order
-    .filter((k) => NOTE_ACTIONS[k])
-    .map((k) => ({ key: k, label: NOTE_ACTIONS[k].label, hint: NOTE_ACTIONS[k].hint }));
-}
-
-/** How much of the note rides along with a command — bounds the tokens, not the meaning. */
-export const NOTE_CONTEXT_MAX_CHARS = 4000;
-
-/**
- * The note itself (minus the command line) as grounding for an `@command` or `@[Agent]` task.
- *
- * "Summarize above", "action items for this meeting", "translate that" — the instruction
- * points at the document it sits in, and a model given only the instruction answers that
- * there is nothing to summarize. So the note travels with the task: everything before the
- * line (`head`) and after it (`tail`), the title when there is one, and a preface telling
- * the model to resolve references — a date, a [[wikilink]], a meeting link's #id — against
- * THIS text rather than free-searching history for a guess.
- *
- * Capped at `max` characters so a long note cannot blow the budget; the client's redaction
- * harness sees it like any other user turn. An empty note yields '' — there is nothing to
- * ground in, and a frame around nothing would only cost tokens.
- */
-export function noteCommandContext(head, tail, { title = '', max = NOTE_CONTEXT_MAX_CHARS } = {}) {
-  const body = `${head ?? ''}\n${tail ?? ''}`.replace(/\n{3,}/g, '\n\n').trim();
-  if (!body) return '';
-  const clipped = body.length > max ? `${body.slice(0, max)}\n…(note truncated)` : body;
-  const t = String(title || '').trim();
-  return `The note I'm editing${t ? ` (title: "${t}")` : ''} is below. Resolve any reference in my instruction — "this meeting", "above", a date, a name, a [[wikilink]] or a URL (a meeting link's #id identifies that exact meeting) — against THIS note, not a guess. If a tool lets you fetch something referenced here by id, use that id.\n\n"""\n${clipped}\n"""`;
-}
-
-/**
- * The user turn for a command: the grounding (when there is any) and then the instruction,
- * separated so the model cannot mistake the note for the ask. One function, because the
- * separator is part of the contract — a client that joined them with a different rule
- * would get a different answer from the same note.
- */
-export function groundedInstruction(instruction, context) {
-  const ask = String(instruction ?? '');
-  return context ? `${context}\n\n---\nInstruction: ${ask}` : ask;
-}
-
-function clamp(n, lo, hi) {
-  const x = Number.isFinite(n) ? n : lo;
-  return Math.max(lo, Math.min(hi, x));
-}
-const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+---
+Instruction: ${r}`:r}function f(e,n,r){const s=Number.isFinite(e)?e:n;return Math.max(n,Math.min(r,s))}const g=e=>e.replace(/[.*+?^${}()|[\]\\/]/g,"\\$&");export{h as NOTE_ACTIONS,y as NOTE_ACTION_ERRORS,p as NOTE_ACTION_ORDER,w as NOTE_ACTION_TEMPERATURE,d as NOTE_COMMANDS,k as NOTE_COMMAND_MAX_TOKENS,T as NOTE_COMMAND_TEMPERATURE,O as NOTE_CONTEXT_MAX_CHARS,S as commandLineAt,z as filterNoteActions,N as frameNoteAction,A as groundedInstruction,_ as noteActionItems,x as noteActionLabel,v as noteCommandContext,E as triggerQueryAt};

package/note-graph.js

@@ -1,158 +1 @@
-// The shape of a corpus: what links to what, and what it is all about.
-//
-// A note graph drawn from `[[wikilinks]]` alone is mostly dust — people link deliberately and
-// rarely, so the picture is a handful of pairs and a hundred lonely dots, which tells you
-// nothing you did not already know. The connective tissue is what notes are ABOUT: a topic
-// shared by two or more notes becomes a node of its own, and the notes hang off it.
-//
-// That is the whole idea, and it is pure: an index of `{ id, title, topics, tags, links }` in,
-// nodes and links out. No DOM, no layout, no physics — a client draws it with SVG, canvas, or
-// a native view, and all of them get the same graph. The extension's `graph-view.js` keeps the
-// drawing; this is the model underneath it.
-//
-// TOPICS ON A SINGLE NOTE ARE DROPPED. A topic that touches one note connects nothing, and
-// drawing it adds a labelled node with exactly one edge — clutter that makes the real clusters
-// harder to see. The threshold is the difference between a graph and a hairball.
-
-/** How many nodes are worth drawing before a view should start trimming. */
-export const MAX_GRAPH_NODES = 140;
-
-const lc = (s) => String(s || '').trim().toLowerCase();
-
-/**
- * Build the note graph.
- *
- * @param {Array} index  `{ id, title, topics?, tags?, links? }` — the lightweight list, not
- *                       the bodies. `links` are wikilink TITLES, resolved here against the
- *                       index's own titles, so a link to a page that does not exist yet draws
- *                       nothing rather than a dangling node.
- * @param {object} [opts]
- * @param {boolean} [opts.topics=true]   include topic hubs
- * @param {number}  [opts.minShared=2]   how many notes a topic needs before it earns a node
- * @returns {{nodes: Array, links: Array}}
- */
-export function buildNoteGraph(index, { topics = true, minShared = 2 } = {}) {
-  const list = Array.isArray(index) ? index.filter(Boolean) : [];
-  const nodes = list.map((n) => ({ id: n.id, label: n.title || 'Untitled note', type: 'note' }));
-  const links = [];
-  const seen = new Set();
-  const addEdge = (s, t, kind) => {
-    if (!s || !t || s === t) return;
-    const key = s < t ? `${s}|${t}` : `${t}|${s}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    links.push({ s, t, kind });
-  };
-
-  // Explicit wikilinks first — a deliberate connection outranks an inferred one, and adding
-  // them first means the dedupe above can never drop one in favour of a topic edge.
-  const byTitle = new Map(list.map((n) => [lc(n.title), n.id]));
-  for (const n of list) {
-    for (const name of n.links || []) {
-      const target = byTitle.get(lc(name));
-      if (target) addEdge(n.id, target, 'link');
-    }
-  }
-
-  if (topics) {
-    const hubs = new Map(); // lowercased topic → { label, ids[] }
-    for (const n of list) {
-      // Tags are the user's own topics and count the same: a corpus where somebody tags by
-      // hand should not draw a sparser graph than one where a model extracted the topics.
-      for (const raw of [...(n.topics || []), ...(n.tags || [])]) {
-        const label = String(raw || '').trim();
-        if (!label) continue;
-        const key = lc(label);
-        const e = hubs.get(key) || { label, ids: [] };
-        if (!e.ids.includes(n.id)) e.ids.push(n.id);
-        hubs.set(key, e);
-      }
-    }
-    for (const [key, { label, ids }] of hubs) {
-      if (ids.length < minShared) continue;
-      const tid = `topic:${key}`;
-      nodes.push({ id: tid, label, type: 'topic' });
-      for (const id of ids) addEdge(id, tid, 'topic');
-    }
-  }
-
-  return { nodes, links };
-}
-
-/**
- * The neighbourhood around one node — BFS out `hops`, keeping only links whose endpoints both
- * survive.
- *
- * A whole-corpus graph answers "what does my thinking look like"; this answers "what is near
- * THIS note", which is the question someone reading a note actually has. Topic hubs count as
- * a hop, so `hops: 2` reaches the sibling notes that share a topic with this one — which is
- * the entire point of having hubs at all.
- */
-export function egoGraph(full, id, hops = 2) {
-  const nodes = full?.nodes || [];
-  const links = full?.links || [];
-  const byId = new Map(nodes.map((n) => [n.id, n]));
-  if (!byId.has(id)) return { nodes: [], links: [] };
-  const adj = new Map();
-  for (const l of links) {
-    if (!adj.has(l.s)) adj.set(l.s, new Set());
-    if (!adj.has(l.t)) adj.set(l.t, new Set());
-    adj.get(l.s).add(l.t);
-    adj.get(l.t).add(l.s);
-  }
-  const inSet = new Set([id]);
-  let frontier = new Set([id]);
-  for (let h = 0; h < hops; h++) {
-    const next = new Set();
-    for (const cur of frontier) {
-      for (const nb of adj.get(cur) || []) if (!inSet.has(nb)) { inSet.add(nb); next.add(nb); }
-    }
-    frontier = next;
-  }
-  return {
-    nodes: [...inSet].map((nid) => {
-      const m = byId.get(nid);
-      return { id: nid, label: m?.label || 'Untitled note', type: m?.type || 'note', focus: nid === id };
-    }),
-    links: links.filter((l) => inSet.has(l.s) && inSet.has(l.t)),
-  };
-}
-
-/**
- * Trim a graph to the most connected `max` nodes, keeping `keep` whatever its degree.
- *
- * A corpus of two thousand notes draws as a grey disc: every renderer slows to a crawl and
- * nothing is legible anyway. Degree is the right thing to cut on — a node nothing connects to
- * carries no information in a picture whose entire subject is connection — and the focused
- * node is exempt, because a view of "around this note" that dropped the note would be absurd.
- */
-export function trimGraph(graph, max = MAX_GRAPH_NODES, keep = '') {
-  const nodes = graph?.nodes || [];
-  const links = graph?.links || [];
-  if (nodes.length <= max) return { nodes, links };
-  const degree = new Map();
-  for (const l of links) {
-    degree.set(l.s, (degree.get(l.s) || 0) + 1);
-    degree.set(l.t, (degree.get(l.t) || 0) + 1);
-  }
-  const ranked = [...nodes].sort((a, b) => {
-    if (a.id === keep) return -1;
-    if (b.id === keep) return 1;
-    return (degree.get(b.id) || 0) - (degree.get(a.id) || 0);
-  }).slice(0, max);
-  const inSet = new Set(ranked.map((n) => n.id));
-  return { nodes: ranked, links: links.filter((l) => inSet.has(l.s) && inSet.has(l.t)) };
-}
-
-/**
- * How many notes, links and topic hubs — the one-line summary a pane shows above the picture,
- * so a graph that looks empty says whether it IS empty or merely unconnected.
- */
-export function graphStats(graph) {
-  const nodes = graph?.nodes || [];
-  return {
-    notes: nodes.filter((n) => n.type !== 'topic').length,
-    topics: nodes.filter((n) => n.type === 'topic').length,
-    links: (graph?.links || []).length,
-  };
-}
+const k=140,h=o=>String(o||"").trim().toLowerCase();function w(o,{topics:r=!0,minShared:f=2}={}){const l=Array.isArray(o)?o.filter(Boolean):[],p=l.map(t=>({id:t.id,label:t.title||"Untitled note",type:"note"})),c=[],s=new Set,d=(t,e,a)=>{if(!t||!e||t===e)return;const i=t<e?`${t}|${e}`:`${e}|${t}`;s.has(i)||(s.add(i),c.push({s:t,t:e,kind:a}))},n=new Map(l.map(t=>[h(t.title),t.id]));for(const t of l)for(const e of t.links||[]){const a=n.get(h(e));a&&d(t.id,a,"link")}if(r){const t=new Map;for(const e of l)for(const a of[...e.topics||[],...e.tags||[]]){const i=String(a||"").trim();if(!i)continue;const u=h(i),g=t.get(u)||{label:i,ids:[]};g.ids.includes(e.id)||g.ids.push(e.id),t.set(u,g)}for(const[e,{label:a,ids:i}]of t){if(i.length<f)continue;const u=`topic:${e}`;p.push({id:u,label:a,type:"topic"});for(const g of i)d(g,u,"topic")}}return{nodes:p,links:c}}function S(o,r,f=2){const l=o?.nodes||[],p=o?.links||[],c=new Map(l.map(t=>[t.id,t]));if(!c.has(r))return{nodes:[],links:[]};const s=new Map;for(const t of p)s.has(t.s)||s.set(t.s,new Set),s.has(t.t)||s.set(t.t,new Set),s.get(t.s).add(t.t),s.get(t.t).add(t.s);const d=new Set([r]);let n=new Set([r]);for(let t=0;t<f;t++){const e=new Set;for(const a of n)for(const i of s.get(a)||[])d.has(i)||(d.add(i),e.add(i));n=e}return{nodes:[...d].map(t=>{const e=c.get(t);return{id:t,label:e?.label||"Untitled note",type:e?.type||"note",focus:t===r}}),links:p.filter(t=>d.has(t.s)&&d.has(t.t))}}function y(o,r=140,f=""){const l=o?.nodes||[],p=o?.links||[];if(l.length<=r)return{nodes:l,links:p};const c=new Map;for(const n of p)c.set(n.s,(c.get(n.s)||0)+1),c.set(n.t,(c.get(n.t)||0)+1);const s=[...l].sort((n,t)=>n.id===f?-1:t.id===f?1:(c.get(t.id)||0)-(c.get(n.id)||0)).slice(0,r),d=new Set(s.map(n=>n.id));return{nodes:s,links:p.filter(n=>d.has(n.s)&&d.has(n.t))}}function b(o){const r=o?.nodes||[];return{notes:r.filter(f=>f.type!=="topic").length,topics:r.filter(f=>f.type==="topic").length,links:(o?.links||[]).length}}export{k as MAX_GRAPH_NODES,w as buildNoteGraph,S as egoGraph,b as graphStats,y as trimGraph};

package/note-links.js

@@ -1,68 +1 @@
-// Linking one note to another: the `[[` picker's grammar.
-//
-// Split from `note-mentions.js` for a reason that is not taxonomy. The mention grammar is
-// asked a question by a KEYSTROKE handler — "is this line a delegation?" — which cannot await
-// a module, so it must already be loaded; the extension's Notes page therefore carries it on
-// its first-paint graph. Link picking happens inside an autocomplete popup, which is async by
-// nature and can load what it needs when the user types the second bracket.
-//
-// Keeping them in one file put both on that graph and pushed the extension's Notes first
-// paint 1.6 KB over its budget. The guard caught it, and this is the shape that answer takes:
-// a module is the unit of loading, so "needed synchronously" and "needed on demand" are not
-// allowed to share one.
-
-/**
- * The `[[…` link query under the caret, or null — `{ query, start, end }`, where [start, end)
- * is the text typed AFTER the opening brackets, which is what a pick replaces.
- *
- * Deliberately not a `triggerQueryAt` trigger: `[[` is two characters, the query may contain
- * spaces (page titles do), and it ends at a `]]` rather than at whitespace. A closed link is
- * not a query — once `]]` is typed the user is past it — and neither is one carrying a newline
- * or another bracket, which mean the `[[` above belongs to something else entirely.
- */
-export function wikiQueryAt(text, pos, { hasSelection = false } = {}) {
-  if (hasSelection) return null;
-  const v = String(text ?? '');
-  const p = Math.max(0, Math.min(Number.isFinite(pos) ? pos : 0, v.length));
-  const upto = v.slice(0, p);
-  const open = upto.lastIndexOf('[[');
-  if (open < 0) return null;
-  const between = upto.slice(open + 2);
-  if (/[[\]\n]/.test(between)) return null;
-  return { query: between, start: open + 2, end: p };
-}
-
-/**
- * Rank link targets for what has been typed.
- *
- * Prefix matches first — someone typing "Roll" means a page whose name STARTS that way, and
- * burying it under a note that mentions "rollback" in the middle of its title is the ranking
- * being clever at the user's expense. Then substring, each group alphabetical so the list is
- * stable between keystrokes.
- *
- * DEDUPED BY TITLE, because a `[[link]]` addresses a title and nothing else: two records
- * called "Atlas" are one destination, and offering the name twice asks the user to choose
- * between two things they cannot tell apart. The first of a title wins, which — given the
- * caller passes its index in its own order — is the one it considers canonical.
- */
-export function rankLinkTargets(targets, query, limit = 8) {
-  const q = String(query || '').trim().toLowerCase();
-  const byTitleSeen = new Set();
-  const list = (Array.isArray(targets) ? targets : []).filter((t) => {
-    if (!t || !t.title) return false;
-    const key = String(t.title).trim().toLowerCase();
-    if (byTitleSeen.has(key)) return false;
-    byTitleSeen.add(key);
-    return true;
-  });
-  const byTitle = (a, b) => String(a.title).localeCompare(String(b.title));
-  if (!q) return [...list].sort(byTitle).slice(0, limit);
-  const starts = [];
-  const has = [];
-  for (const t of list) {
-    const title = String(t.title).toLowerCase();
-    if (title.startsWith(q)) starts.push(t);
-    else if (title.includes(q)) has.push(t);
-  }
-  return [...starts.sort(byTitle), ...has.sort(byTitle)].slice(0, limit);
-}
+function f(l,c,{hasSelection:u=!1}={}){if(u)return null;const r=String(l??""),s=Math.max(0,Math.min(Number.isFinite(c)?c:0,r.length)),i=r.slice(0,s),e=i.lastIndexOf("[[");if(e<0)return null;const o=i.slice(e+2);return/[[\]\n]/.test(o)?null:{query:o,start:e+2,end:s}}function h(l,c,u=8){const r=String(c||"").trim().toLowerCase(),s=new Set,i=(Array.isArray(l)?l:[]).filter(t=>{if(!t||!t.title)return!1;const n=String(t.title).trim().toLowerCase();return s.has(n)?!1:(s.add(n),!0)}),e=(t,n)=>String(t.title).localeCompare(String(n.title));if(!r)return[...i].sort(e).slice(0,u);const o=[],a=[];for(const t of i){const n=String(t.title).toLowerCase();n.startsWith(r)?o.push(t):n.includes(r)&&a.push(t)}return[...o.sort(e),...a.sort(e)].slice(0,u)}export{h as rankLinkTargets,f as wikiQueryAt};

package/note-mentions.js

@@ -1,117 +1,11 @@
-// Delegation inside a note: `@[Agent Name] task` and `#[Skill Name]`.
-//
-// A note is not only a document a model writes INTO — it is a place to hand a job to a named
-// agent and scope it to a saved skill. Both are written as tokens in the text, which means
-// both are grammar: something has to say where the token ends and the instruction begins, and
-// two clients answering that differently is one feature behaving as two.
-//
-// These were `notes-util.js` in the extension — already pure, already tested, and already the
-// right shape; they simply lived where only one client could reach them. The desktop needs
-// exactly the same answers, and a mobile client will too.
-//
-// WHAT IS NOT HERE: running the agent, arming its tools, and streaming into the editor. Those
-// need a target resolver, a transport and a document — all platform. What is here is the
-// reading of the line and the resolving of a name against a list the caller supplies.
+function a(i){const e=String(i||""),n=e.match(/@\[([^\]\n]+)\]/);if(!n)return{name:"",task:""};const t=n[1].trim(),s=`${e.slice(0,n.index)} ${e.slice(n.index+n[0].length)}`.replace(/\s+/g," ").trim();return{name:t,task:s}}function l(i,e){const n=String(i??""),t=Math.max(0,Math.min(Number.isFinite(e)?e:0,n.length)),s=n.lastIndexOf(`
+`,t-1)+1;let o=n.indexOf(`
+`,t);o<0&&(o=n.length);const{name:r,task:c}=a(n.slice(s,o));return!r||!c?null:{name:r,task:c,start:s,end:o}}function u(i){const e=String(i||""),n=e.match(/#\[([^\]\n]+)\]/);return n?{name:n[1].trim(),text:e.replace(n[0],"").replace(/[ \t]{2,}/g," ").trim()}:{name:"",text:e.trim()}}function m(i,e){const n=String(i||""),t=String(e||"");return/\{\{\s*input[^}]*\}\}/i.test(n)?n.replace(/\{\{\s*input[^}]*\}\}/gi,t):n?t?`${n}
 
-/**
- * Pull an `@[Agent Name] task` mention out of one line.
- *
- * The instruction may sit BEFORE or AFTER the token — "Update the plan @[Codex]" and
- * "@[Codex] update the plan" are the same request — so the task is the whole line minus the
- * token. Brackets are what let an agent's name contain spaces.
- *
- * Returns `{ name, task }`, both `''` when the line carries no runnable mention. A mention
- * with no task is not runnable: `@[Codex]` alone is someone still typing.
- */
-export function parseAgentMention(line) {
-  const s = String(line || '');
-  const m = s.match(/@\[([^\]\n]+)\]/);
-  if (!m) return { name: '', task: '' };
-  const name = m[1].trim();
-  const task = (`${s.slice(0, m.index)} ${s.slice(m.index + m[0].length)}`).replace(/\s+/g, ' ').trim();
-  return { name, task };
-}
+${t}`:n:t}function f(i,e){const n=String(e||"").trim().toLowerCase();if(!n)return null;const t=Array.isArray(i)?i:[],s=o=>String(o?.name||o?.title||"").toLowerCase();return t.find(o=>s(o)===n)||t.find(o=>s(o).includes(n))||null}function g(i,e){const n=String(e||"").trim().toLowerCase();if(!n)return null;const t=Array.isArray(i)?i:[],s=r=>String(r?.name||"").toLowerCase(),o=r=>String(r?.model||r?.bridgeAgent||r?.id||"").toLowerCase();return t.find(r=>s(r)===n)||t.find(r=>o(r)===n)||t.find(r=>s(r)&&s(r).includes(n))||t.find(r=>o(r).includes(n))||null}function d(i,e){return`${String(e||"").split(`
+`).map(t=>`> ${t}`).join(`
+`)}
 
-/**
- * The runnable `@[Agent] task` on the caret's line, or null — `{ name, task, start, end }`
- * where [start, end) is the WHOLE line, because the Q&A replaces the line it was written on.
- */
-export function agentMentionAt(text, pos) {
-  const v = String(text ?? '');
-  const p = Math.max(0, Math.min(Number.isFinite(pos) ? pos : 0, v.length));
-  const start = v.lastIndexOf('\n', p - 1) + 1;
-  let end = v.indexOf('\n', p);
-  if (end < 0) end = v.length;
-  const { name, task } = parseAgentMention(v.slice(start, end));
-  if (!name || !task) return null;
-  return { name, task, start, end };
-}
+**${String(i||"Agent")}:**
 
-/**
- * Pull a `#[Skill Name]` out of an instruction. Returns the name (or `''`) and the
- * instruction with the token removed — the token is addressing, not content, and leaving it
- * in means the model is asked to do something with the literal text "#[Weekly review]".
- */
-export function parseSkillMention(instruction) {
-  const s = String(instruction || '');
-  const m = s.match(/#\[([^\]\n]+)\]/);
-  if (!m) return { name: '', text: s.trim() };
-  return { name: m[1].trim(), text: s.replace(m[0], '').replace(/[ \t]{2,}/g, ' ').trim() };
-}
-
-/**
- * Merge a skill's saved prompt with the user's task.
- *
- * `{{input}}` placeholders are substituted when the author wrote any — a skill that says
- * "Summarize {{input}} for an exec" wants the task in the middle, not stapled underneath.
- * With no placeholder the task is appended, which is what an instruction-style skill expects.
- */
-export function mergeSkillPrompt(prompt, task) {
-  const p = String(prompt || '');
-  const t = String(task || '');
-  if (/\{\{\s*input[^}]*\}\}/i.test(p)) return p.replace(/\{\{\s*input[^}]*\}\}/gi, t);
-  return p ? (t ? `${p}\n\n${t}` : p) : t;
-}
-
-/** Resolve a skill by display name — exact first, then contains. */
-export function findSkillByName(skills, name) {
-  const q = String(name || '').trim().toLowerCase();
-  if (!q) return null;
-  const list = Array.isArray(skills) ? skills : [];
-  const of = (s) => String(s?.name || s?.title || '').toLowerCase();
-  return list.find((s) => of(s) === q) || list.find((s) => of(s).includes(q)) || null;
-}
-
-/**
- * Resolve a mentioned TARGET by name against whatever list the client has.
- *
- * Exact name, then a contains match, then the underlying model or agent id — so `@[Claude]`
- * finds "Claude Code", and `@[codex]` finds a target named something else that runs `codex`.
- * The entries are duck-typed (`name`, `model`, `bridgeAgent`, or a bare `id`) because the
- * extension holds configured endpoints and agents while the desktop holds the gateway's model
- * list, and neither should have to reshape its data to ask this question.
- */
-export function findTargetByName(targets, name) {
-  const q = String(name || '').trim().toLowerCase();
-  if (!q) return null;
-  const list = Array.isArray(targets) ? targets : [];
-  const nameOf = (t) => String(t?.name || '').toLowerCase();
-  const idOf = (t) => String(t?.model || t?.bridgeAgent || t?.id || '').toLowerCase();
-  return list.find((t) => nameOf(t) === q)
-    || list.find((t) => idOf(t) === q)
-    || list.find((t) => nameOf(t) && nameOf(t).includes(q))
-    || list.find((t) => idOf(t).includes(q))
-    || null;
-}
-
-/**
- * How a delegated answer is written into the note.
- *
- * The question is quoted and the agent named above its reply, so a note that collected three
- * delegations reads as a transcript rather than as three anonymous blocks of prose. Returned
- * separately from the answer because the client streams INTO the gap between them.
- */
-export function mentionAnswerPrefix(name, task) {
-  const quoted = String(task || '').split('\n').map((l) => `> ${l}`).join('\n');
-  return `${quoted}\n\n**${String(name || 'Agent')}:**\n\n`;
-}
+`}export{l as agentMentionAt,f as findSkillByName,g as findTargetByName,d as mentionAnswerPrefix,m as mergeSkillPrompt,a as parseAgentMention,u as parseSkillMention};