@chatpanel/events 0.54.0 → 0.61.0

package/cowriter-router.js

@@ -0,0 +1,77 @@
+// Who does which job: appointing a model to each role of the co-writer team.
+//
+// A co-writer is not one model. Proofreading runs constantly and must be cheap; drafting
+// ahead runs rarely and should be the best thing available; research sits between them. Using
+// one model for all three means either paying strong-model prices to catch "the the", or
+// asking a small model to write prose. So each ROLE states a preference and this appoints the
+// nearest candidate to it.
+//
+// Pure and dependency-free on purpose — no settings, no license, no DOM. The caller
+// normalizes whatever roster it holds (the extension's configured endpoints and agents, the
+// desktop's gateway model list) into candidates; this only decides. That is what makes the
+// same appointment logic available to a gateway or a bridge that wanted to offer it.
+//
+// candidate: { id, name, kind, model, tier?, subagents?, usable? }
+// role:      { id, prefer: 'cheap' | 'balanced' | 'strong' }
+
+const TIER_RANK = { cheap: 0, balanced: 1, strong: 2 };
+
+// Infer a capability tier from a model id (best-effort, provider-agnostic).
+export function classifyModel(model = '') {
+  const m = String(model).toLowerCase();
+  if (/haiku|mini|flash|nano|lite|small|instant|\b[1-9]b\b|8b|7b|3b/.test(m)) return 'cheap';
+  if (/opus|ultra|o1|o3|405b|70b|72b|large|gpt-4(?!o)|gpt-5/.test(m)) return 'strong';
+  if (/sonnet|gpt-4o|mixtral|medium|32b|command-r/.test(m)) return 'balanced';
+  return 'balanced'; // unknown → treat as mid so it's never wrongly picked as "cheapest"
+}
+
+// Native-subagent capable = bridge CLIs that orchestrate their own subagents.
+export function supportsSubagents(candidate) {
+  return candidate?.kind === 'bridge' && /^(claude|codex)$/i.test(candidate.bridgeAgent || candidate.model || '');
+}
+
+function withTierAndMode(c) {
+  const tier = c.tier || classifyModel(c.model);
+  return { ...c, tier, mode: (c.subagents ?? supportsSubagents(c)) ? 'subagent' : 'api' };
+}
+
+// Appoint one role → the best available candidate (or null if none usable).
+export function appoint(role, candidates, { overrides = {} } = {}) {
+  const usable = (candidates || []).filter((c) => c && c.usable !== false && c.model);
+  if (!usable.length) return null;
+  const ovId = overrides[role.id];
+  if (ovId) {
+    const m = usable.find((c) => c.id === ovId);
+    if (m) return withTierAndMode(m);
+  }
+  const want = TIER_RANK[role.prefer] ?? 1;
+  const best = usable
+    .map((c) => ({ c: withTierAndMode(c), d: Math.abs((TIER_RANK[classifyModel(c.model)] ?? 1) - want) }))
+    .sort((a, b) => a.d - b.d || (a.c.name || a.c.id).localeCompare(b.c.name || b.c.id))[0];
+  return best.c;
+}
+
+// Appoint a whole team → { [roleId]: appointment | null }.
+export function routeTeam(roles, candidates, opts = {}) {
+  const out = {};
+  for (const role of roles || []) out[role.id] = appoint(role, candidates, opts);
+  return out;
+}
+
+/**
+ * The team, and what each member is for.
+ *
+ * Here rather than in a client because a role is a CONTRACT — "the editor proofreads as you
+ * type, cheaply, constantly" — and a second client inventing its own list is a client whose
+ * Writer is not the same job as everyone else's. The icons and descriptions travel with it so
+ * two products describe the team in one voice.
+ */
+export const SWARM_ROLES = Object.freeze([
+  Object.freeze({ id: 'editor', prefer: 'cheap', icon: '\u270d\ufe0f', name: 'Editor', desc: 'Proofreads as you type' }),
+  Object.freeze({ id: 'researcher', prefer: 'balanced', icon: '\ud83d\udd0e', name: 'Researcher', desc: 'Finds related material' }),
+  Object.freeze({ id: 'writer', prefer: 'strong', icon: '\u2728', name: 'Writer', desc: 'Drafts ahead and rewrites' }),
+  Object.freeze({ id: 'factcheck', prefer: 'strong', icon: '\u26a0\ufe0f', name: 'Fact-checker', desc: 'Flags shaky claims' }),
+]);
+
+/** A role by id, or null — so a stored override naming a role this build dropped is ignored. */
+export const roleById = (id) => SWARM_ROLES.find((r) => r.id === id) || null;

package/cowriter.js

@@ -0,0 +1,190 @@
+// The co-writer's two deterministic halves: what is mechanically wrong with a paragraph, and
+// what the SMALLEST change is that fixes a sentence.
+//
+// A co-writer that replaces a paragraph with its own version is a rewriter, and people do not
+// want their prose rewritten — they want the doubled word caught. Everything here exists to
+// keep a suggestion small enough to accept with one click and small enough to be obviously
+// right when you look at it.
+//
+// THE DETERMINISTIC PASS RUNS FIRST, AND OFTEN ENDS IT. `lintText` catches the mechanical
+// mistakes — doubled words, double spaces, a space before a comma, the lone lowercase "i" —
+// for free, so a token is spent only on text that is already mechanically clean. That order
+// is the difference between a co-writer that idles at zero cost and one that bills for
+// noticing "the the".
+//
+// Both halves were `cowriter-lint.js` and `cowriter-diff.js` in the extension, written pure
+// and dependency-free from the start and explicitly noted there as portable. They are here so
+// the second and third clients inherit them rather than copy them.
+
+// ── the deterministic pass ──────────────────────────────────────────────────────────────
+
+/**
+ * Mechanical mistakes in `text`, as minimal edits.
+ *
+ * Returns `[{ start, end, before, after }]` — the same shape `wordDiff` produces, so a client
+ * renders a lint fix and a model fix with one component — non-overlapping and left-to-right.
+ */
+export function lintText(text = '') {
+  const src = String(text);
+  const raw = [];
+  const add = (start, end, after) => {
+    if (after !== src.slice(start, end)) raw.push({ start, end, before: src.slice(start, end), after });
+  };
+  let m;
+
+  // 1) doubled word: "the the" → "the" (case-insensitive, same word).
+  const dup = /\b(\w+)(\s+)\1\b/gi;
+  while ((m = dup.exec(src))) add(m.index, m.index + m[0].length, m[1]);
+
+  // 2) a run of 2+ spaces between visible chars → a single space.
+  const runs = /(\S)( {2,})(\S)/g;
+  while ((m = runs.exec(src))) { const s = m.index + 1; add(s, s + m[2].length, ' '); runs.lastIndex = s + 1; }
+
+  // 3) whitespace before sentence punctuation: "word ," → "word,".
+  const sp = /(\S)(\s+)([,.;:!?])/g;
+  while ((m = sp.exec(src))) add(m.index + 1, m.index + m[0].length, m[3]);
+
+  // 4) standalone lowercase "i" → "I" (skipping the "i.e." abbreviation).
+  const iRe = /(^|[ \t(])i(?=[ \t.,;:!?)]|$)/g;
+  while ((m = iRe.exec(src))) {
+    const at = m.index + m[1].length;
+    if (src[at + 1] === '.' && /[a-z]/i.test(src[at + 2] || '')) continue; // i.e., i.g.
+    add(at, at + 1, 'I');
+  }
+
+  // Sort left-to-right and drop any edit overlapping one already kept: two fixes over the
+  // same characters cannot both be applied, and applying one invalidates the other's offsets.
+  raw.sort((a, b) => a.start - b.start || a.end - b.end);
+  const out = [];
+  let lastEnd = -1;
+  for (const e of raw) {
+    if (e.start < lastEnd) continue;
+    out.push(e);
+    lastEnd = e.end;
+  }
+  return out;
+}
+
+// ── the minimal diff ────────────────────────────────────────────────────────────────────
+
+/** Non-whitespace tokens with their char offsets in the source string. */
+function words(text) {
+  const out = [];
+  const re = /\S+/g;
+  let m;
+  while ((m = re.exec(text))) out.push({ w: m[0], start: m.index, end: m.index + m[0].length });
+  return out;
+}
+
+/** Matched index pairs between two word arrays (longest common subsequence). */
+function lcsPairs(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Int32Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i][j] = a[i].w === b[j].w ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i].w === b[j].w) { pairs.push([i, j]); i++; j++; }
+    else if (dp[i + 1][j] >= dp[i][j + 1]) i++;
+    else j++;
+  }
+  return pairs;
+}
+
+/**
+ * Minimal edits turning `original` into `corrected`, with offsets into `original`.
+ *
+ * Word-run replacements, insertions (start === end, before '') and deletions (after ''). The
+ * whitespace handling is the fiddly half and the reason this is one tested function rather
+ * than an idea each client implements: an insertion carries a space so the new word is not
+ * glued to its neighbour, and a deletion absorbs one adjacent space so it leaves neither a
+ * double space nor a leading one.
+ */
+export function wordDiff(original, corrected) {
+  const A = words(original);
+  const B = words(corrected);
+  const matches = lcsPairs(A, B);
+  const edits = [];
+  const push = (aFrom, aTo, bFrom, bTo) => {
+    if (aFrom === aTo && bFrom === bTo) return;
+    const insWords = B.slice(bFrom, bTo).map((x) => x.w);
+    let start;
+    let end;
+    let after;
+    if (aFrom === aTo) {
+      if (aFrom < A.length) { start = A[aFrom].start; end = start; after = `${insWords.join(' ')} `; }
+      else { start = A.length ? A[A.length - 1].end : 0; end = start; after = `${A.length ? ' ' : ''}${insWords.join(' ')}`; }
+    } else if (bFrom === bTo) {
+      start = A[aFrom].start;
+      if (aTo < A.length) end = A[aTo].start;
+      else { end = A[aTo - 1].end; if (aFrom > 0) start = A[aFrom - 1].end; }
+      after = '';
+    } else {
+      start = A[aFrom].start;
+      end = A[aTo - 1].end;
+      after = insWords.join(' ');
+    }
+    edits.push({ start, end, before: original.slice(start, end), after });
+  };
+  let ai = 0;
+  let bi = 0;
+  for (const [am, bm] of matches) {
+    if (am > ai || bm > bi) push(ai, am, bi, bm);
+    ai = am + 1;
+    bi = bm + 1;
+  }
+  if (ai < A.length || bi < B.length) push(ai, A.length, bi, B.length);
+  return edits;
+}
+
+/**
+ * Keep only SMALL corrections — a typo, a comma, a missing "the".
+ *
+ * Without this the co-writer restructures prose: ask a model to "fix the mistakes" in a
+ * paragraph and it will happily return a better paragraph, which arrives here as one enormous
+ * edit and is offered as a one-click "fix". A suggestion nobody can check at a glance is not
+ * a suggestion, so anything large is dropped rather than shown.
+ */
+export function filterTypoEdits(edits, { maxWords = 5, maxLen = 48 } = {}) {
+  return (edits || []).filter((e) => {
+    if (e.before === e.after) return false;
+    if (e.before.length > maxLen || e.after.length > maxLen) return false;
+    const bw = e.before ? e.before.split(/\s+/).length : 0;
+    const aw = e.after ? e.after.split(/\s+/).length : 0;
+    if (Math.max(bw, aw) > maxWords) return false;
+    // A pure insertion is only "small" if it is a word or two (a missing "the", a comma).
+    if (!e.before && aw > 2) return false;
+    return true;
+  });
+}
+
+/** Stable identity for a suggestion, so a fix the user dismissed is not offered again. */
+export function editKey(edit) {
+  return `${edit.before}␟${edit.after}`;
+}
+
+/** Apply non-overlapping edits right-to-left, so earlier offsets stay valid as it goes. */
+export function applyEdits(text, edits) {
+  let out = String(text);
+  for (const e of [...(edits || [])].sort((a, b) => b.start - a.start)) {
+    out = out.slice(0, e.start) + e.after + out.slice(e.end);
+  }
+  return out;
+}
+
+/**
+ * The instruction a co-writing model is given, and the guardrail inside it.
+ *
+ * It is told to return the corrected text and NOTHING else, because the answer is diffed
+ * against the original rather than read: a preamble becomes a spurious insertion at offset 0,
+ * offered to the user as a "fix" that pastes "Sure, here is the corrected text:" into their
+ * note.
+ */
+export const COWRITER_SYSTEM = 'You are a meticulous copy editor. Fix ONLY spelling, grammar, punctuation and obvious word mistakes in the text. Do NOT rewrite, rephrase, restructure, shorten or improve the style, and do not add or remove content. Preserve the markdown exactly. Output ONLY the corrected text.';
+export const COWRITER_TEMPERATURE = 0;

package/index.js

@@ -18,6 +18,43 @@ export {
 export { REF_KINDS, RESOLUTION, makeRef, isRef, resolveRef } from './ref.js';
 export { linearize, compareEvents, causesAreWellFormed } from './order.js';
 export { pendingQueue, isQueued, dequeue, moveQueued, promoteQueued } from './queue.js';
+export {
+  groupModels, filterSections, defaultModelId, modelSummary,
+} from './model-picker.js';
+export {
+  NOTE_ACTIONS, NOTE_ACTION_ORDER, NOTE_ACTION_TEMPERATURE, NOTE_ACTION_ERRORS,
+  NOTE_COMMANDS, NOTE_COMMAND_TEMPERATURE, NOTE_COMMAND_MAX_TOKENS,
+  frameNoteAction, noteActionLabel, noteActionItems, filterNoteActions,
+  commandLineAt, triggerQueryAt,
+} from './note-actions.js';
+export {
+  parseAgentMention, agentMentionAt, parseSkillMention, mergeSkillPrompt,
+  findSkillByName, findTargetByName, mentionAnswerPrefix,
+} from './note-mentions.js';
+export { wikiQueryAt, rankLinkTargets } from './note-links.js';
+export {
+  SWARM_ROLES, roleById, classifyModel, supportsSubagents, appoint, routeTeam,
+} from './cowriter-router.js';
+export {
+  SEARCH_ENGINES, RESULTS_PER_ENGINE, buildSearchUrl, unwrapRedirect, isResultHost,
+  pickResults, mergeEngineResults, engineOrder,
+} from './web-search.js';
+export {
+  MAX_GRAPH_NODES, buildNoteGraph, egoGraph, trimGraph, graphStats,
+} from './note-graph.js';
+export {
+  lintText, wordDiff, filterTypoEdits, editKey, applyEdits,
+  COWRITER_SYSTEM, COWRITER_TEMPERATURE,
+} from './cowriter.js';
+export {
+  salientTerms, topicTerms, researchRelevance, webQuery, researchSnippet,
+  rankResearchCards, mergeResearchLanes,
+} from './note-research.js';
+export {
+  PLAN_ROLES, PLAN_AUTHORS, PLAN_DECOMPOSE_SYSTEM, PLAN_DECOMPOSE_MAX_TOKENS,
+  PLAN_DECOMPOSE_TEMPERATURE, PLAN_SECTION_MAX_TOKENS, PLAN_SECTION_TEMPERATURE,
+  planSectionSystem, parsePlanTasks, planTitleFor, planParts, planBody, planAttribution,
+} from './note-plan.js';
 export { REACH, reachRank, reachSatisfies } from './reach.js';
 export { UPCASTERS, upcast, upcastAll } from './upcast.js';
 export {

package/model-picker.js

@@ -0,0 +1,186 @@
+// THE MODEL PICKER'S SHAPE — one flat list of models in, the menu a person can read out.
+//
+// Every client is handed the same flat array by the gateway's /v1/models: fifty-odd entries
+// mixing local CLI agents with a dozen providers' cloud models, in whatever order the routing
+// table happened to enumerate them. Rendered literally that is a single scrolling column of
+// opaque ids — `claude-code`, `gpt-4o-mini`, `qwen2.5-coder:7b` — where the two things a user
+// actually distinguishes are invisible:
+//
+//   • AN AGENT IS NOT A MODEL. A bridge-backed CLI runs on this machine, holds a session, can
+//     touch files and costs a process; a cloud model is a stateless HTTP call. Picking between
+//     them is a different decision from picking between two models, and a flat list forces
+//     both decisions through one control.
+//   • A PROVIDER IS THE UNIT PEOPLE THINK IN. "the Anthropic one", "my Ollama". Sorting by id
+//     interleaves providers so the same provider's models are scattered down the list.
+//
+// So this turns the flat list into SECTIONS, and it lives here rather than in a client because
+// it is pure input → output with no window in it: the desktop renders it as a menu, the
+// extension as its agent menu, a mobile client as a grouped list, and all three group and
+// order identically. Writing it in one client is how `displayName` got duplicated.
+//
+// UNAVAILABLE MODELS ARE KEPT, NOT DROPPED. A CLI the user has not installed is the single
+// most common reason a first message fails, and a picker that silently omits it answers
+// "where did Claude Code go?" with nothing. It is listed, ordered last within its section,
+// flagged, and carries the reason — see `reason` on the entry.
+
+/** A bridge-backed CLI agent, as opposed to an HTTP model endpoint. */
+const isAgent = (m) => m?.providerType === 'agent' || m?.viaBridge === true;
+
+/**
+ * The provider a model belongs to, in the words the gateway used.
+ *
+ * `provider` is what gateways from 0.6.64 report; `owned_by`/`owner` is the older field. A
+ * name is NEVER parsed for a provider — reading `gpt-` as "OpenAI" breaks the moment someone
+ * serves a GPT-named model from their own Ollama, and that user's whole point was that it is
+ * local.
+ */
+const providerOf = (m) => String(m?.provider || m?.owner || '').trim();
+
+/**
+ * How a provider is spelled when a person wrote it down.
+ *
+ * Capitalising the first letter is right for `anthropic` and wrong for every brand with
+ * internal capitals — it renders "Openai", "Deepseek", "Xai". A heading is the most-read text
+ * in the picker, and misspelling the company in it reads as carelessness about everything
+ * else, so the handful that do not follow the rule are simply listed.
+ */
+const PROVIDER_NAMES = {
+  openai: 'OpenAI', openrouter: 'OpenRouter', deepseek: 'DeepSeek', xai: 'xAI',
+  vllm: 'vLLM', lmstudio: 'LM Studio', llamacpp: 'llama.cpp', 'llama.cpp': 'llama.cpp',
+  huggingface: 'Hugging Face', togetherai: 'Together AI', together: 'Together AI',
+  githubcopilot: 'GitHub Copilot', awsbedrock: 'AWS Bedrock', bedrock: 'AWS Bedrock',
+  azureopenai: 'Azure OpenAI', googleai: 'Google AI', vertexai: 'Vertex AI',
+};
+
+/** Sentence case for a bare provider slug, leaving names that already have shape alone. */
+function providerLabel(raw) {
+  const p = String(raw || '').trim();
+  if (!p) return 'Other';
+  const known = PROVIDER_NAMES[p.toLowerCase().replace(/[\s_-]/g, '')];
+  if (known) return known;
+  if (/[A-Z ]/.test(p)) return p;              // already presentable: "Together AI", "MyCorp LLM"
+  return p.charAt(0).toUpperCase() + p.slice(1);
+}
+
+const availableFirst = (a, b) => (
+  (a.available === false) - (b.available === false)
+  || String(a.id).localeCompare(String(b.id))
+);
+
+/**
+ * Group a flat model list into the sections a picker draws.
+ *
+ * Sections come back in the order they should be shown: **Agents first**, then each provider
+ * alphabetically. Agents lead because a local CLI is the one target a fresh install can be
+ * sure of — no key, no account — which is the same reason `target-choice.js` defaults to one.
+ *
+ * @param models   the gateway's models, each `{ id, provider, providerType, viaBridge,
+ *                 available, reason, owner, label? }`
+ * @param selectedId  currently chosen id, so a caller can mark it without a second pass
+ * @returns `[{ key, label, kind: 'agent'|'provider', items: [...] }]`, where each item is the
+ *          model object plus `{ label, selected }`. Empty sections are never emitted.
+ */
+export function groupModels(models, { selectedId = '' } = {}) {
+  const list = Array.isArray(models) ? models.filter(Boolean) : [];
+
+  const agents = [];
+  const byProvider = new Map();
+  for (const m of list) {
+    if (isAgent(m)) { agents.push(m); continue; }
+    const key = providerOf(m) || 'other';
+    if (!byProvider.has(key)) byProvider.set(key, []);
+    byProvider.get(key).push(m);
+  }
+
+  const decorate = (m) => ({
+    ...m,
+    label: m.label || m.id,
+    selected: !!selectedId && m.id === selectedId,
+  });
+
+  const sections = [];
+  if (agents.length) {
+    sections.push({
+      key: 'agents',
+      label: 'Agents',
+      kind: 'agent',
+      items: agents.slice().sort(availableFirst).map(decorate),
+    });
+  }
+  for (const key of [...byProvider.keys()].sort((a, b) => a.localeCompare(b))) {
+    sections.push({
+      key: `provider:${key}`,
+      label: providerLabel(key),
+      kind: 'provider',
+      items: byProvider.get(key).slice().sort(availableFirst).map(decorate),
+    });
+  }
+  return sections;
+}
+
+/**
+ * Filter the grouped sections by a typed query, keeping the grouping.
+ *
+ * A provider name matches ALL of its models: someone typing "ollama" is asking to see that
+ * provider, not to see the models whose ids happen to contain the string — and with local
+ * models the id usually does not contain it at all.
+ *
+ * Sections that end up empty are dropped, so an unmatched provider does not leave a heading
+ * floating over nothing.
+ */
+export function filterSections(sections, query) {
+  const q = String(query || '').trim().toLowerCase();
+  if (!q) return sections;
+  const out = [];
+  for (const s of sections) {
+    if (s.label.toLowerCase().includes(q)) { out.push(s); continue; }
+    const items = s.items.filter((m) => (
+      String(m.label).toLowerCase().includes(q) || String(m.id).toLowerCase().includes(q)
+    ));
+    if (items.length) out.push({ ...s, items });
+  }
+  return out;
+}
+
+/**
+ * The id a picker should start on when the record does not name one.
+ *
+ * Prefers a REACHABLE agent, then any reachable model, and only then something known to be
+ * unavailable. The rule is the product's, and it is the same one `target-choice.js` states:
+ * never default to a target that cannot answer, because the user is the one who finds out.
+ */
+export function defaultModelId(models) {
+  const list = Array.isArray(models) ? models.filter(Boolean) : [];
+  const usable = list.filter((m) => m.available !== false);
+  return (usable.find(isAgent) || usable[0] || list[0] || {}).id || '';
+}
+
+/**
+ * How to describe the chosen model in one line — what the picker's own button says.
+ *
+ * The three-valued `available` is the honesty rule applied to a button: an id that names
+ * nothing is only BROKEN if there was a list for it to be absent from. Before /v1/models has
+ * answered there is no such list, so the truthful answer is `null` — "nobody has looked yet"
+ * — and a caller must not paint that as a red dot. Marking an unloaded picker unavailable is
+ * the same mistake as drawing "0 redactions" when nothing was inspected.
+ */
+export function modelSummary(models, id) {
+  const list = Array.isArray(models) ? models.filter(Boolean) : [];
+  const m = list.find((x) => x.id === id);
+  if (!m) {
+    return {
+      label: id || 'No model',
+      available: list.length ? false : null,
+      reason: list.length && id ? `${id} is not offered by the gateway any more` : '',
+      agent: false,
+      provider: '',
+    };
+  }
+  return {
+    label: m.label || m.id,
+    available: m.available !== false,
+    reason: m.reason || '',
+    agent: isAgent(m),
+    provider: providerLabel(providerOf(m)),
+  };
+}