@chatpanel/events 0.102.0 → 0.103.1

package/cowriter-router.js

@@ -1,83 +1 @@
-// 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 = {}, exclude = null } = {}) {
-  // `exclude` — ids (or model names) that failed this run: the next appointment is the
-  // nearest tier among what is left, which is what a person would do by hand.
-  const out = exclude ? new Set(exclude) : null;
-  const usable = (candidates || []).filter((c) => c && c.usable !== false && c.model && !(out && (out.has(c.id) || out.has(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;
-  // Ties go to ROSTER ORDER, not to the alphabet: the host lists what it trusts first (the
-  // model the person is already chatting with, installed agents), and over a gateway that
-  // lists eight hundred models the alphabet picks a provider nobody has used.
-  const best = usable
-    .map((c, i) => ({ c: withTierAndMode(c), d: Math.abs((TIER_RANK[classifyModel(c.model)] ?? 1) - want), i }))
-    .sort((a, b) => a.d - b.d || a.i - b.i)[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;
+const c={cheap:0,balanced:1,strong:2};function u(e=""){const r=String(e).toLowerCase();return/haiku|mini|flash|nano|lite|small|instant|\b[1-9]b\b|8b|7b|3b/.test(r)?"cheap":/opus|ultra|o1|o3|405b|70b|72b|large|gpt-4(?!o)|gpt-5/.test(r)?"strong":(/sonnet|gpt-4o|mixtral|medium|32b|command-r/.test(r),"balanced")}function b(e){return e?.kind==="bridge"&&/^(claude|codex)$/i.test(e.bridgeAgent||e.model||"")}function f(e){const r=e.tier||u(e.model);return{...e,tier:r,mode:e.subagents??b(e)?"subagent":"api"}}function p(e,r,{overrides:a={},exclude:s=null}={}){const n=s?new Set(s):null,i=(r||[]).filter(t=>t&&t.usable!==!1&&t.model&&!(n&&(n.has(t.id)||n.has(t.model))));if(!i.length)return null;const d=a[e.id];if(d){const t=i.find(o=>o.id===d);if(t)return f(t)}const l=c[e.prefer]??1;return i.map((t,o)=>({c:f(t),d:Math.abs((c[u(t.model)]??1)-l),i:o})).sort((t,o)=>t.d-o.d||t.i-o.i)[0].c}function h(e,r,a={}){const s={};for(const n of e||[])s[n.id]=p(n,r,a);return s}const m=Object.freeze([Object.freeze({id:"editor",prefer:"cheap",icon:"✍️",name:"Editor",desc:"Proofreads as you type"}),Object.freeze({id:"researcher",prefer:"balanced",icon:"🔎",name:"Researcher",desc:"Finds related material"}),Object.freeze({id:"writer",prefer:"strong",icon:"✨",name:"Writer",desc:"Drafts ahead and rewrites"}),Object.freeze({id:"factcheck",prefer:"strong",icon:"⚠️",name:"Fact-checker",desc:"Flags shaky claims"})]),x=e=>m.find(r=>r.id===e)||null;export{m as SWARM_ROLES,p as appoint,u as classifyModel,x as roleById,h as routeTeam,b as supportsSubagents};

package/cowriter-writer.js

@@ -1,199 +1,25 @@
-// cowriter-writer.js — the WRITER's half of the co-writer: when it may draft, what it is
-// asked, and how much it may spend.
-//
-// The Editor's half (lint, diff, the copy-editor prompt) is cowriter.js. This is the member
-// that WRITES — a continuation from the caret on ⌘↵, a section under a heading you paused on,
-// the next line toward a goal, or the result of an instruction typed into the note — and it
-// lived as a dozen functions inside the extension's notes.js until the desktop needed the
-// same member. Everything here is a decision or a string; the ghost text, the keys and the
-// stream are the client's.
-//
-// The standing rule of this member: IT OFFERS, THE USER ACCEPTS. Every draft is a suggestion
-// with an accept and a reject, and nothing here writes into a document.
+function c(r,n){const e=String(r??""),t=Math.max(0,Math.min(n??0,e.length)),o=e.lastIndexOf(`
+`,t-1)+1,s=e.indexOf(`
+`,t),i=s<0?e.length:s;return{text:e.slice(o,i),start:o,end:i}}function m(r,n){const e=String(r??""),t=c(e,n),o=t.text;if(/^\s*([-*]|\d+\.)\s*(\[ \]\s*)?$/.test(o))return{kind:"item",at:t.end,label:"this item"};if(/\b(TODO|TK|TBD)\b:?\s*$/i.test(o))return{kind:"todo",at:t.end,label:"this to-do"};if(/^#{1,6}\s+\S/.test(o)){const s=e.slice(t.end).replace(/^\n/,"").split(`
+`,1)[0]||"";if(!s.trim()||/^#{1,6}\s/.test(s))return{kind:"section",at:t.end,label:"this section"}}if(!o.trim()){const s=e.slice(0,t.start).replace(/\n$/,""),i=s.slice(s.lastIndexOf(`
+`)+1);if(/^#{1,6}\s+\S/.test(i))return{kind:"section",at:t.start,label:"this section"}}return null}const u=/^\s*(?:please\s+|can you\s+|now\s+)?(summari[sz]e|recap|tl;?dr|rewrite|re-?write|reword|rephrase|expand|elaborate|continue|list|enumerate|outline|draft|write|compose|generate|create|add|explain|describe|define|compare|contrast|shorten|condense|tighten|simplify|translate|convert|turn\s+.+\s+into|make\s+(?:this|it|these|a\b)|bullet|brainstorm|suggest|proofread|polish|improve)\b/i;function g(r,n){const e=c(r,n),t=e.text.trim();return t.length<6||/^[@/]/.test(t)||/@\[[^\]]+\]/.test(t)||!u.test(t)?null:{text:t,start:e.start,end:e.end}}const p=24;function x({text:r,caret:n,lastLen:e=-1,minNew:t=p}={}){const o=String(r??""),s=Math.max(0,Math.min(n??0,o.length));return!(s!==o.length&&o[s]!==`
+`||o.slice(0,s).trim().length<24||e>=0&&o.length<=e+t)}function b({capPerMin:r=20,now:n=Date.now}={}){let e=[];const t=()=>{const o=n();e=e.filter(s=>o-s<6e4)};return{cap:r,ok(){return t(),e.length<r},spend(){e.push(n())},used(){return t(),e.length}}}function l(r,n=""){const e=String(r??""),t=e.length>1600?`…${e.slice(-1600)}`:e,o=String(n||"").trim();return(o?`# ${o}
 
-// ── What the cursor line affords ─────────────────────────────────────────────────
+`:"")+t}function w(r){const n=String(r??"");return n.endsWith(`
 
-/** The line the caret is on, as `{ text, start, end }` — `end` excludes the newline. */
-export function lineAt(text, caret) {
-  const src = String(text ?? '');
-  const pos = Math.max(0, Math.min(caret ?? 0, src.length));
-  const start = src.lastIndexOf('\n', pos - 1) + 1;
-  const nl = src.indexOf('\n', pos);
-  const end = nl < 0 ? src.length : nl;
-  return { text: src.slice(start, end), start, end };
-}
+`)?"":n.endsWith(`
+`)?`
+`:`
 
-/**
- * What the cursor line affords the Writer: an empty outline item, a TODO marker, or a
- * heading whose section has no body yet → `{ kind, at, label }`, or null. Detecting the
- * spot is free; drafting it is a model call, and only happens on a nudge, ⌘↵ or Focus.
- */
-export function writerAffordance(text, caret) {
-  const v = String(text ?? '');
-  const line = lineAt(v, caret);
-  const t = line.text;
-  if (/^\s*([-*]|\d+\.)\s*(\[ \]\s*)?$/.test(t)) return { kind: 'item', at: line.end, label: 'this item' };
-  if (/\b(TODO|TK|TBD)\b:?\s*$/i.test(t)) return { kind: 'todo', at: line.end, label: 'this to-do' };
-  if (/^#{1,6}\s+\S/.test(t)) { // a heading whose section has no body yet
-    const next = v.slice(line.end).replace(/^\n/, '').split('\n', 1)[0] || '';
-    if (!next.trim() || /^#{1,6}\s/.test(next)) return { kind: 'section', at: line.end, label: 'this section' };
-  }
-  if (!t.trim()) { // a blank line directly under a heading
-    const before = v.slice(0, line.start).replace(/\n$/, '');
-    const prev = before.slice(before.lastIndexOf('\n') + 1);
-    if (/^#{1,6}\s+\S/.test(prev)) return { kind: 'section', at: line.start, label: 'this section' };
-  }
-  return null;
-}
+`}function f(r=[],{limit:n=5}={}){const e=(Array.isArray(r)?r:[]).filter(t=>t&&t.title).slice(0,n);return e.length?`
 
-/**
- * An imperative line the user wants ACTED on — "summarize the above in 3 sentences", "list
- * the key risks", "rewrite this as bullets" — as distinct from prose to continue. A
- * conservative verb-led match, never an @mention or a /command line (those run elsewhere).
- */
-export const INSTRUCTION_RE = /^\s*(?:please\s+|can you\s+|now\s+)?(summari[sz]e|recap|tl;?dr|rewrite|re-?write|reword|rephrase|expand|elaborate|continue|list|enumerate|outline|draft|write|compose|generate|create|add|explain|describe|define|compare|contrast|shorten|condense|tighten|simplify|translate|convert|turn\s+.+\s+into|make\s+(?:this|it|these|a\b)|bullet|brainstorm|suggest|proofread|polish|improve)\b/i;
+Related material you may draw on (only if genuinely useful — cite as [[title]] or [text](url)):
+`+e.map(t=>`- ${t.title}${t.snippet?` — ${t.snippet}`:""}`).join(`
+`):""}function O({before:r,title:n="",instruction:e="",contextBefore:t=null,intent:o="",cards:s=[]}={}){const i=f(s),a=String(o||"").trim();return e?{system:`You are executing an instruction inside the user's note. Use the note as context and do EXACTLY what the instruction says. Match the note's voice, tone, and markdown style. Output ONLY the resulting markdown to insert — no preamble, no restating the instruction, no meta commentary.${a?` The note's goal: ${a}.`:""}${i}`,user:`NOTE SO FAR:
+${l(t??r,n)}
 
-export function instructionOnLine(text, caret) {
-  const line = lineAt(text, caret);
-  const t = line.text.trim();
-  if (t.length < 6) return null;
-  if (/^[@/]/.test(t) || /@\[[^\]]+\]/.test(t)) return null;
-  if (!INSTRUCTION_RE.test(t)) return null;
-  return { text: t, start: line.start, end: line.end };
-}
+INSTRUCTION (do exactly this, output only the result):
+${e}`,maxTokens:600,temperature:.4}:{system:`${a?`The note's goal (guide your writing toward it): ${a}.
 
-// ── Goal-drive ───────────────────────────────────────────────────────────────────
-
-/** Chars of the user's OWN writing required between two automatic drafts. */
-export const GOAL_MIN_NEW = 24;
-
-/**
- * May the goal draft the next line now?
- *
- * It must NOT loop: without this guard it re-fires on every pause (each Enter changes the
- * length) and re-drafts near-duplicates. So it fires at most once per burst of the user's
- * own writing — the document must have grown by `minNew` chars since the last draft, the
- * caret must sit at a line end, and there must be real context to continue. `lastLen` is
- * the body length at the last draft (-1 = armed: fire once there is context); the caller
- * re-baselines it when a draft is accepted, so an accepted line does not trigger the next.
- */
-export function goalDraftAllowed({ text, caret, lastLen = -1, minNew = GOAL_MIN_NEW } = {}) {
-  const v = String(text ?? '');
-  const from = Math.max(0, Math.min(caret ?? 0, v.length));
-  if (from !== v.length && v[from] !== '\n') return false;
-  if (v.slice(0, from).trim().length < 24) return false;
-  if (lastLen >= 0 && v.length <= lastLen + minNew) return false;
-  return true;
-}
-
-// ── Spend ────────────────────────────────────────────────────────────────────────
-
-/**
- * A rolling per-minute cap on MODEL calls the team makes on its own. Free work — the
- * deterministic Editor pass, retrieval-only research — never counts; over the cap the
- * spending members skip until the window clears. Visible, so "why did it stop" has an answer.
- */
-export function createSpendMeter({ capPerMin = 20, now = Date.now } = {}) {
-  let calls = [];
-  const prune = () => { const t = now(); calls = calls.filter((c) => t - c < 60_000); };
-  return {
-    cap: capPerMin,
-    ok() { prune(); return calls.length < capPerMin; },
-    spend() { calls.push(now()); },
-    used() { prune(); return calls.length; },
-  };
-}
-
-// ── Prompts ──────────────────────────────────────────────────────────────────────
-
-/** The tail of the note the Writer continues from — capped, with the title as context. */
-export function writerTail(before, title = '') {
-  const b = String(before ?? '');
-  const tail = b.length > 1600 ? `…${b.slice(-1600)}` : b;
-  const t = String(title || '').trim();
-  return (t ? `# ${t}\n\n` : '') + tail;
-}
-
-/** Where an instruction's result goes: on its own line under the instruction. */
-export function draftSeparator(before) {
-  const b = String(before ?? '');
-  return b.endsWith('\n\n') ? '' : b.endsWith('\n') ? '\n' : '\n\n';
-}
-
-/** The Researcher's shelf, as the lines the Writer may draw on — a handoff, not a dump. */
-export function groundingBlock(cards = [], { limit = 5 } = {}) {
-  const list = (Array.isArray(cards) ? cards : []).filter((c) => c && c.title).slice(0, limit);
-  if (!list.length) return '';
-  return '\n\nRelated material you may draw on (only if genuinely useful — cite as [[title]] or [text](url)):\n'
-    + list.map((c) => `- ${c.title}${c.snippet ? ` — ${c.snippet}` : ''}`).join('\n');
-}
-
-/**
- * The Writer's request: a continuation from where the note stops, or an instruction executed
- * over the note above it. -> { system, user, maxTokens, temperature }
- */
-export function writerRequest({ before, title = '', instruction = '', contextBefore = null, intent = '', cards = [] } = {}) {
-  const grounding = groundingBlock(cards);
-  const goal = String(intent || '').trim();
-  if (instruction) {
-    return {
-      system: `You are executing an instruction inside the user's note. Use the note as context and do EXACTLY what the instruction says. Match the note's voice, tone, and markdown style. Output ONLY the resulting markdown to insert — no preamble, no restating the instruction, no meta commentary.${goal ? ` The note's goal: ${goal}.` : ''}${grounding}`,
-      user: `NOTE SO FAR:\n${writerTail(contextBefore ?? before, title)}\n\nINSTRUCTION (do exactly this, output only the result):\n${instruction}`,
-      maxTokens: 600,
-      temperature: 0.4,
-    };
-  }
-  return {
-    system: `${goal ? `The note's goal (guide your writing toward it): ${goal}.\n\n` : ''}You continue the user's note from where it stops. Match their voice, tone, and markdown style exactly. Write only the NEXT one or two sentences (or finish the current one) — concise, natural, no preamble, no repetition of prior text, no meta commentary. Output ONLY the continuation.${grounding}`,
-    user: writerTail(before, title),
-    maxTokens: 220,
-    temperature: 0.6,
-  };
-}
-
-/** Inline autocomplete: a few words, at most one sentence, at the very end of the note. */
-export const AUTOCOMPLETE_SYSTEM = 'You are an inline writing autocomplete. Continue the note from EXACTLY where it stops with a SHORT continuation — a few words up to one sentence. Match the voice and markdown. Output ONLY the text to append: no quotes, no preamble, no repetition of prior text. If nothing sensible follows, output nothing.';
-export const AUTOCOMPLETE_MAX_TOKENS = 48;
-export const AUTOCOMPLETE_TEMPERATURE = 0.1;
-
-/** Keep a completion short: the first line, and at most the first sentence of it. */
-export function clipCompletion(s) {
-  let t = String(s ?? '').replace(/^\s+/, '');
-  const nl = t.indexOf('\n');
-  if (nl >= 0) t = t.slice(0, nl);
-  const m = t.match(/^.*?[.!?](\s|$)/);
-  if (m) t = m[0];
-  return t.replace(/\s+$/, '');
-}
-
-// ── The switches, in one voice ───────────────────────────────────────────────────
-
-/** The two gears — and what each DOES to your text, which is the question. */
-export const GEARS = Object.freeze([
-  Object.freeze({ id: 'ambient', name: 'Suggest', note: 'Nothing is written for you. Typo fixes, links and research collect quietly in the Co-writer tab, and you decide what to take. Press ⌘↵ any time to draft ahead.' }),
-  Object.freeze({ id: 'focus', name: 'Write with me', note: 'The team writes alongside you: it drafts a section when you pause on a heading, and every draft is still accept-or-reject. The per-minute spend cap still applies.' }),
-]);
-
-/** The opt-ins. Each is a model call the team may make WITHOUT being asked, so each is off. */
-export const WRITER_PREFS = Object.freeze([
-  Object.freeze({ k: 'revealFixes', label: 'Show fixes as they land', desc: 'Open the Co-writer tab when a typo fix or a draft is ready — no hunting for the badge.', spends: false }),
-  Object.freeze({ k: 'actOnInstructions', label: 'Act on instruction lines', desc: 'A line like “summarize the above in 3 sentences” becomes a task the Writer drafts (accept/reject).', spends: true }),
-  Object.freeze({ k: 'goalDrive', label: 'Let the goal keep writing', desc: 'With a goal set, draft the next line toward it whenever you pause at a line end. Always accept/reject; respects the spend cap.', spends: true }),
-  Object.freeze({ k: 'autocomplete', label: 'Autocomplete as I type', desc: 'A short ghost continuation at the end of the note after a pause — one small call per pause, Tab keeps it. Counts against the spend cap.', spends: true }),
-]);
-
-export const WRITER_PREF_DEFAULTS = Object.freeze({ gear: 'ambient', revealFixes: false, actOnInstructions: false, goalDrive: false, autocomplete: false });
-
-/** A stored prefs object, with unknown keys dropped and missing ones defaulted. */
-export function normalizeWriterPrefs(stored) {
-  const s = stored && typeof stored === 'object' ? stored : {};
-  const out = { ...WRITER_PREF_DEFAULTS };
-  out.gear = s.gear === 'focus' ? 'focus' : 'ambient';
-  for (const p of WRITER_PREFS) out[p.k] = s[p.k] === true;
-  return out;
-}
-
-/** A note's goal, as stored: one line, capped. */
-export function normalizeIntent(v) {
-  return String(v || '').replace(/\s+/g, ' ').trim().slice(0, 200);
-}
+`:""}You continue the user's note from where it stops. Match their voice, tone, and markdown style exactly. Write only the NEXT one or two sentences (or finish the current one) — concise, natural, no preamble, no repetition of prior text, no meta commentary. Output ONLY the continuation.${i}`,user:l(r,n),maxTokens:220,temperature:.6}}const y="You are an inline writing autocomplete. Continue the note from EXACTLY where it stops with a SHORT continuation — a few words up to one sentence. Match the voice and markdown. Output ONLY the text to append: no quotes, no preamble, no repetition of prior text. If nothing sensible follows, output nothing.",T=48,k=.1;function S(r){let n=String(r??"").replace(/^\s+/,"");const e=n.indexOf(`
+`);e>=0&&(n=n.slice(0,e));const t=n.match(/^.*?[.!?](\s|$)/);return t&&(n=t[0]),n.replace(/\s+$/,"")}const E=Object.freeze([Object.freeze({id:"ambient",name:"Suggest",note:"Nothing is written for you. Typo fixes, links and research collect quietly in the Co-writer tab, and you decide what to take. Press ⌘↵ any time to draft ahead."}),Object.freeze({id:"focus",name:"Write with me",note:"The team writes alongside you: it drafts a section when you pause on a heading, and every draft is still accept-or-reject. The per-minute spend cap still applies."})]),d=Object.freeze([Object.freeze({k:"revealFixes",label:"Show fixes as they land",desc:"Open the Co-writer tab when a typo fix or a draft is ready — no hunting for the badge.",spends:!1}),Object.freeze({k:"actOnInstructions",label:"Act on instruction lines",desc:"A line like “summarize the above in 3 sentences” becomes a task the Writer drafts (accept/reject).",spends:!0}),Object.freeze({k:"goalDrive",label:"Let the goal keep writing",desc:"With a goal set, draft the next line toward it whenever you pause at a line end. Always accept/reject; respects the spend cap.",spends:!0}),Object.freeze({k:"autocomplete",label:"Autocomplete as I type",desc:"A short ghost continuation at the end of the note after a pause — one small call per pause, Tab keeps it. Counts against the spend cap.",spends:!0})]),h=Object.freeze({gear:"ambient",revealFixes:!1,actOnInstructions:!1,goalDrive:!1,autocomplete:!1});function A(r){const n=r&&typeof r=="object"?r:{},e={...h};e.gear=n.gear==="focus"?"focus":"ambient";for(const t of d)e[t.k]=n[t.k]===!0;return e}function $(r){return String(r||"").replace(/\s+/g," ").trim().slice(0,200)}export{T as AUTOCOMPLETE_MAX_TOKENS,y as AUTOCOMPLETE_SYSTEM,k as AUTOCOMPLETE_TEMPERATURE,E as GEARS,p as GOAL_MIN_NEW,u as INSTRUCTION_RE,d as WRITER_PREFS,h as WRITER_PREF_DEFAULTS,S as clipCompletion,b as createSpendMeter,w as draftSeparator,x as goalDraftAllowed,f as groundingBlock,g as instructionOnLine,c as lineAt,$ as normalizeIntent,A as normalizeWriterPrefs,m as writerAffordance,O as writerRequest,l as writerTail};

package/cowriter.js

@@ -1,190 +1 @@
-// 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;
+function S(o=""){const i=String(o),t=[],e=(r,d,p)=>{p!==i.slice(r,d)&&t.push({start:r,end:d,before:i.slice(r,d),after:p})};let n;const h=/\b(\w+)(\s+)\1\b/gi;for(;n=h.exec(i);)e(n.index,n.index+n[0].length,n[1]);const f=/(\S)( {2,})(\S)/g;for(;n=f.exec(i);){const r=n.index+1;e(r,r+n[2].length," "),f.lastIndex=r+1}const l=/(\S)(\s+)([,.;:!?])/g;for(;n=l.exec(i);)e(n.index+1,n.index+n[0].length,n[3]);const c=/(^|[ \t(])i(?=[ \t.,;:!?)]|$)/g;for(;n=c.exec(i);){const r=n.index+n[1].length;i[r+1]==="."&&/[a-z]/i.test(i[r+2]||"")||e(r,r+1,"I")}t.sort((r,d)=>r.start-d.start||r.end-d.end);const s=[];let u=-1;for(const r of t)r.start<u||(s.push(r),u=r.end);return s}function w(o){const i=[],t=/\S+/g;let e;for(;e=t.exec(o);)i.push({w:e[0],start:e.index,end:e.index+e[0].length});return i}function y(o,i){const t=o.length,e=i.length,n=Array.from({length:t+1},()=>new Int32Array(e+1));for(let c=t-1;c>=0;c--)for(let s=e-1;s>=0;s--)n[c][s]=o[c].w===i[s].w?n[c+1][s+1]+1:Math.max(n[c+1][s],n[c][s+1]);const h=[];let f=0,l=0;for(;f<t&&l<e;)o[f].w===i[l].w?(h.push([f,l]),f++,l++):n[f+1][l]>=n[f][l+1]?f++:l++;return h}function b(o,i){const t=w(o),e=w(i),n=y(t,e),h=[],f=(s,u,r,d)=>{if(s===u&&r===d)return;const p=e.slice(r,d).map(E=>E.w);let a,g,x;s===u?s<t.length?(a=t[s].start,g=a,x=`${p.join(" ")} `):(a=t.length?t[t.length-1].end:0,g=a,x=`${t.length?" ":""}${p.join(" ")}`):r===d?(a=t[s].start,u<t.length?g=t[u].start:(g=t[u-1].end,s>0&&(a=t[s-1].end)),x=""):(a=t[s].start,g=t[u-1].end,x=p.join(" ")),h.push({start:a,end:g,before:o.slice(a,g),after:x})};let l=0,c=0;for(const[s,u]of n)(s>l||u>c)&&f(l,s,c,u),l=s+1,c=u+1;return(l<t.length||c<e.length)&&f(l,t.length,c,e.length),h}function m(o,{maxWords:i=5,maxLen:t=48}={}){return(o||[]).filter(e=>{if(e.before===e.after||e.before.length>t||e.after.length>t)return!1;const n=e.before?e.before.split(/\s+/).length:0,h=e.after?e.after.split(/\s+/).length:0;return!(Math.max(n,h)>i||!e.before&&h>2)})}function R(o){return`${o.before}␟${o.after}`}function O(o,i){let t=String(o);for(const e of[...i||[]].sort((n,h)=>h.start-n.start))t=t.slice(0,e.start)+e.after+t.slice(e.end);return t}const $="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.",j=0;export{$ as COWRITER_SYSTEM,j as COWRITER_TEMPERATURE,O as applyEdits,R as editKey,m as filterTypoEdits,S as lintText,b as wordDiff};