@chatpanel/events 0.33.0 → 0.46.0

package/theme.js

@@ -0,0 +1,155 @@
+// THE PALETTE, AS DATA — so every client paints the same product.
+//
+// These values are not new. They are the extension's shipped dashboard stylesheet
+// (`meetings.css`, which `notes.css` and `briefs.css` both build on), lifted out of CSS and
+// into a form a non-CSS client can read. A SwiftUI or Compose client cannot import a
+// stylesheet, and a desktop app that re-types the hexes will drift the first time one is
+// tuned — which is the same failure mode as the record model, in a smaller coat.
+//
+// WHAT BELONGS HERE AND WHAT DOES NOT. Tokens are shared; layout is not. A color named
+// `--risk` means the same thing in every surface, so it is a contract. The width of a rail,
+// the height of a row and the shape of a shadow are rendering decisions each platform makes
+// for itself, and pretending otherwise is how a Mac app ends up looking like a web page.
+//
+// TWO THEMES, ONE SET OF NAMES. Every token exists in both themes — a name defined in only
+// one is what produces the invisible-text-in-light-mode bug. `TOKEN_NAMES` is the guard:
+// a test asserts both themes carry exactly it.
+
+export const THEMES = Object.freeze(['light', 'dark']);
+
+/**
+ * Semantic roles, and what each is FOR — the part a hex value cannot carry.
+ *
+ * `bg` is the window; `card` is a raised surface on it; `elev` is raised again (a popover);
+ * `field` is a recessed surface (an input, a well). Getting that ladder wrong is why some
+ * dark UIs look flat: the surfaces must step in one direction.
+ */
+export const TOKEN_ROLES = Object.freeze({
+  bg: 'the window ground',
+  card: 'a surface raised off the ground',
+  elev: 'a surface raised off a card — popovers, overlays',
+  field: 'a recessed surface — inputs, wells, meters',
+  border: 'hairline separators',
+  borderStrong: 'a border that must be seen, not merely felt',
+  text: 'primary reading colour',
+  muted: 'secondary text that is still content',
+  faint: 'labels, captions and metadata',
+  accent: 'the product colour — selection, links, the active mode',
+  accentWeak: 'accent as a background wash',
+  decision: 'something settled',
+  risk: 'something that can hurt',
+  question: 'something open',
+  person: 'a person subject',
+  topic: 'a topic subject',
+  tag: 'a tag subject',
+  title: 'a title subject',
+});
+
+export const TOKEN_NAMES = Object.freeze(Object.keys(TOKEN_ROLES));
+
+export const LIGHT = Object.freeze({
+  bg: '#f5f6f8',
+  card: '#ffffff',
+  elev: '#ffffff',
+  field: '#f7f8fa',
+  border: '#e4e7ec',
+  borderStrong: '#d3d8e0',
+  text: '#181b20',
+  muted: '#646b76',
+  faint: '#8a909b',
+  accent: '#5b5bf0',
+  accentWeak: 'rgba(91,91,240,.10)',
+  decision: '#15a34a',
+  risk: '#dc2626',
+  question: '#b45309',
+  person: '#7c4dff',
+  topic: '#0b84ff',
+  tag: '#17a673',
+  title: '#b7791f',
+});
+
+export const DARK = Object.freeze({
+  bg: '#0e1014',
+  card: '#16191f',
+  elev: '#1b1f26',
+  field: '#1f242c',
+  border: '#272c34',
+  borderStrong: '#353c46',
+  text: '#e9ebee',
+  muted: '#9aa1ac',
+  faint: '#6b7280',
+  accent: '#818cf8',
+  accentWeak: 'rgba(129,140,248,.13)',
+  decision: '#34d399',
+  risk: '#f87171',
+  question: '#fbbf24',
+  person: '#7c4dff',
+  topic: '#0b84ff',
+  tag: '#17a673',
+  title: '#b7791f',
+});
+
+export const PALETTES = Object.freeze({ light: LIGHT, dark: DARK });
+
+/** Shape values that are the same in both themes, so they are stated once. */
+export const SHAPE = Object.freeze({
+  radius: '13px',
+  radiusSm: '9px',
+  radiusXs: '5px',
+  mono: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+  sans: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+});
+
+export function paletteFor(theme) {
+  return PALETTES[theme] || DARK;
+}
+
+/** camelCase → the `--kebab-case` custom property the stylesheets already use. */
+export function cssVarName(token) {
+  return `--${String(token).replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}`;
+}
+
+/**
+ * A palette as CSS custom-property declarations.
+ *
+ * Returns only the declarations — the caller wraps them in whatever selector its theming
+ * strategy needs (`:root`, `[data-theme="dark"]`, a media query). Deciding the selector here
+ * would force one strategy on every client.
+ */
+export function toCssVars(theme, { includeShape = false } = {}) {
+  const palette = paletteFor(theme);
+  const lines = TOKEN_NAMES.map((name) => `  ${cssVarName(name)}: ${palette[name]};`);
+  if (includeShape) {
+    for (const [k, v] of Object.entries(SHAPE)) lines.push(`  ${cssVarName(k)}: ${v};`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * A complete, theme-aware stylesheet block for a web client.
+ *
+ * Three selectors, and all three are needed: bare `:root` is the light default, the media
+ * query serves the "system" setting that stamps no attribute, and `[data-theme]` lets an
+ * explicit choice win in BOTH directions. A client that ships only the media query cannot
+ * offer a theme switch that overrides the OS.
+ */
+export function themeStylesheet() {
+  return [
+    `:root {\n${toCssVars('light', { includeShape: true })}\n  color-scheme: light;\n}`,
+    `@media (prefers-color-scheme: dark) {\n  :root:not([data-theme="light"]) {\n${toCssVars('dark')}\n    color-scheme: dark;\n  }\n}`,
+    `:root[data-theme="dark"] {\n${toCssVars('dark')}\n  color-scheme: dark;\n}`,
+    `:root[data-theme="light"] {\n${toCssVars('light')}\n  color-scheme: light;\n}`,
+  ].join('\n\n');
+}
+
+/**
+ * Resolve the theme actually in force.
+ *
+ * `preference` is what the user chose — `'light'`, `'dark'` or `'system'`; `systemDark` is
+ * what the OS reports. Kept as a function because three surfaces need the same answer and
+ * two of them cannot read a media query.
+ */
+export function resolveTheme(preference, systemDark = false) {
+  if (preference === 'light' || preference === 'dark') return preference;
+  return systemDark ? 'dark' : 'light';
+}

package/voice-intents.js

@@ -34,6 +34,11 @@ import {
 // answer in this package — a second copy here would drift, and two features would disagree
 // about the same caption on the same screen.
 import { DANGLING_TAILS } from './schedule.js';
+// The wake matcher's fuzzy compare. It lived here until the maintenance pass needed the
+// same question answered; re-exported so every existing caller (and index.js) is unchanged.
+import { editDistance } from './distance.js';
+
+export { editDistance };
 
 export class VoiceIntentError extends Error {
   constructor(code, message) { super(message); this.name = 'VoiceIntentError'; this.code = code; }
@@ -56,29 +61,6 @@ const MAX_WAKE_TOKENS = 3;
 // and a wake phrase longer than this is a sentence, not a wake phrase.
 const WAKE_TOKEN_CEILING = 8;
 
-// Bounded Levenshtein — returns early once the distance cannot come in under `max`, so a
-// wake scan over a long transcript stays linear in practice.
-export function editDistance(a, b, max = Infinity) {
-  if (a === b) return 0;
-  if (Math.abs(a.length - b.length) > max) return max + 1;
-  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i++) {
-    const cur = [i];
-    let best = i;
-    for (let j = 1; j <= b.length; j++) {
-      cur[j] = Math.min(
-        prev[j] + 1,
-        cur[j - 1] + 1,
-        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
-      );
-      if (cur[j] < best) best = cur[j];
-    }
-    if (best > max) return max + 1;
-    prev = cur;
-  }
-  return prev[b.length];
-}
-
 // Lowercase and blank out punctuation WITHOUT changing length, so every offset computed
 // against the normalised copy still points at the same character of the original. The
 // command text handed back to the user keeps its capitals and its apostrophes; matching

package/weather.js

@@ -0,0 +1,211 @@
+// Weather — one deterministic source, asked first, with search as the fallback.
+//
+// There was no weather capability at all, so every "how is the weather in X" went to
+// web_search and the model assembled an answer from whatever three sites it happened to
+// scrape. That is slow (several page fetches for one number), inconsistent between asks, and
+// it failed in the way scraping fails: a repeated search got refused by the loop guard, the
+// reworded retry returned nothing, and the model announced it had no access to weather.
+//
+// wttr.in answers the whole question in ONE request as JSON, which is why it is the default.
+// It is not authoritative and it is not always up, so the tool falls back to search rather
+// than pretending — but the common case costs one round trip and reads the same every time.
+//
+// THE GEOCODER IS THE KNOWN WEAKNESS, and it is handled by disclosure rather than cleverness.
+// "Issaquah" once resolved to somewhere obscure and the answer looked plausible and was for
+// the wrong place. wttr.in reports what it actually resolved to, so `formatWeather` always
+// prints that line: a wrong place is then visible instead of silent. Guessing a region on the
+// user's behalf would replace a visible error with an invisible one.
+//
+// Pure and platform-free, like every other module here: the fetch is INJECTED, so the
+// extension passes its SSRF-guarded secureFetch, the gateway passes its own, and neither has
+// a second copy of the parsing.
+
+export const WEATHER_HOST = 'https://wttr.in';
+
+/** Long enough for a cold CDN edge, short enough that a hung host still falls back. */
+export const WEATHER_TIMEOUT_MS = 7000;
+
+export class WeatherError extends Error {
+  constructor(code, message) { super(message); this.name = 'WeatherError'; this.code = code; }
+}
+
+/**
+ * The URL for one location.
+ *
+ * The location goes in the PATH, so it is percent-encoded whole — a bare `encodeURIComponent`
+ * of "Seattle, WA" gives `Seattle%2C%20WA`, which wttr.in reads correctly, while leaving the
+ * comma raw would let a location containing `/` or `?` reshape the request. Never interpolate
+ * an unencoded user string into a path.
+ */
+export function weatherUrl(location, { host = WEATHER_HOST } = {}) {
+  const q = String(location ?? '').trim();
+  if (!q) throw new WeatherError('NO_LOCATION', 'a location is required');
+  if (q.length > 120) throw new WeatherError('BAD_LOCATION', 'location is too long to be one');
+  return `${host}/${encodeURIComponent(q)}?format=j1`;
+}
+
+const num = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+};
+const str = (v) => String(v ?? '').trim();
+// wttr.in nests half its scalars as [{ value: "…" }], which is a shape, not data.
+const firstValue = (v) => (Array.isArray(v) ? str(v[0]?.value) : str(v));
+
+/**
+ * wttr.in's `format=j1` body → a shape that does not mention wttr.in.
+ *
+ * Returns null for anything unusable rather than throwing: a malformed body and an outage are
+ * the same event to the caller, and both mean "fall back to search".
+ */
+export function parseWeather(json, { query = '' } = {}) {
+  if (!json || typeof json !== 'object') return null;
+  const cur = Array.isArray(json.current_condition) ? json.current_condition[0] : null;
+  if (!cur) return null;
+  const tempC = num(cur.temp_C);
+  const tempF = num(cur.temp_F);
+  // A reading with no temperature is not a weather reading. Guarded because an error page
+  // served as JSON still parses into an object, and half-empty output read as real data is
+  // worse than no data.
+  if (tempC === null && tempF === null) return null;
+
+  const areaRaw = Array.isArray(json.nearest_area) ? json.nearest_area[0] : null;
+  const area = areaRaw ? {
+    name: firstValue(areaRaw.areaName),
+    region: firstValue(areaRaw.region),
+    country: firstValue(areaRaw.country),
+    lat: num(areaRaw.latitude),
+    lon: num(areaRaw.longitude),
+  } : null;
+
+  const days = (Array.isArray(json.weather) ? json.weather : []).slice(0, 3).map((d) => ({
+    date: str(d.date),
+    maxC: num(d.maxtempC),
+    maxF: num(d.maxtempF),
+    minC: num(d.mintempC),
+    minF: num(d.mintempF),
+    sunrise: str(d.astronomy?.[0]?.sunrise),
+    sunset: str(d.astronomy?.[0]?.sunset),
+    // The midday slot is the day's headline condition; the array is 3-hourly.
+    condition: firstValue(d.hourly?.[4]?.weatherDesc) || firstValue(d.hourly?.[0]?.weatherDesc),
+    chanceOfRain: num(d.hourly?.[4]?.chanceofrain),
+  }));
+
+  return {
+    query: str(query),
+    area,
+    now: {
+      tempC,
+      tempF,
+      feelsLikeC: num(cur.FeelsLikeC),
+      feelsLikeF: num(cur.FeelsLikeF),
+      condition: firstValue(cur.weatherDesc),
+      humidity: num(cur.humidity),
+      windKph: num(cur.windspeedKmph),
+      windMph: num(cur.windspeedMiles),
+      windDir: str(cur.winddir16Point),
+      precipMm: num(cur.precipMM),
+      uv: num(cur.uvIndex),
+      observedAt: str(cur.localObsDateTime),
+    },
+    days,
+  };
+}
+
+/** "Seattle, Washington, United States" — whatever of it exists, deduped. */
+export function areaLabel(area, fallback = '') {
+  if (!area) return fallback;
+  const parts = [area.name, area.region, area.country].map(str).filter(Boolean);
+  const seen = new Set();
+  const uniq = parts.filter((p) => {
+    const k = p.toLowerCase();
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+  return uniq.join(', ') || fallback;
+}
+
+/**
+ * True when the user named a bare place with no region or country.
+ *
+ * Not used to REWRITE the query — that is how you turn a wrong answer into a confidently
+ * wrong one. It is used to add a line telling the model to say which place it got, so the
+ * user can correct it. Dozens of towns are called Fairview.
+ */
+export function isAmbiguousLocation(location) {
+  const q = str(location);
+  if (!q) return false;
+  return !/[,]/.test(q) && q.split(/\s+/).length <= 2;
+}
+
+const c2f = (c) => Math.round((c * 9) / 5 + 32);
+const temp = (c, f) => {
+  const cc = c === null && f !== null ? Math.round(((f - 32) * 5) / 9) : c;
+  const ff = f === null && c !== null ? c2f(c) : f;
+  if (cc === null && ff === null) return '';
+  if (cc === null) return `${ff}°F`;
+  if (ff === null) return `${cc}°C`;
+  return `${ff}°F / ${cc}°C`;
+};
+
+/** What the model reads. Compact — this is one fact, not a report. */
+export function formatWeather(w) {
+  if (!w) return '';
+  const where = areaLabel(w.area, w.query);
+  const lines = [];
+  // FIRST LINE NAMES THE PLACE IT ACTUALLY RESOLVED. The geocoder picks obscure matches for
+  // bare town names, and an answer that does not say where it is from cannot be caught.
+  lines.push(`Weather for ${where}${w.query && where.toLowerCase() !== w.query.toLowerCase() ? ` (asked: "${w.query}")` : ''}`);
+  const n = w.now;
+  const now = [`Now: ${temp(n.tempC, n.tempF)}`];
+  if (n.feelsLikeC !== null || n.feelsLikeF !== null) now.push(`feels like ${temp(n.feelsLikeC, n.feelsLikeF)}`);
+  if (n.condition) now.push(n.condition.toLowerCase());
+  lines.push(now.join(', '));
+  const detail = [];
+  if (n.humidity !== null) detail.push(`humidity ${n.humidity}%`);
+  if (n.windMph !== null || n.windKph !== null) {
+    detail.push(`wind ${n.windMph !== null ? `${n.windMph} mph` : `${n.windKph} km/h`}${n.windDir ? ` ${n.windDir}` : ''}`);
+  }
+  if (n.precipMm !== null) detail.push(`precip ${n.precipMm} mm`);
+  if (n.uv !== null) detail.push(`UV ${n.uv}`);
+  if (detail.length) lines.push(detail.join(' · '));
+  for (const d of w.days) {
+    const range = `${temp(d.maxC, d.maxF)} high / ${temp(d.minC, d.minF)} low`;
+    const rain = d.chanceOfRain !== null ? `, ${d.chanceOfRain}% rain` : '';
+    lines.push(`${d.date}: ${range}${d.condition ? `, ${d.condition.toLowerCase()}` : ''}${rain}`);
+  }
+  if (n.observedAt) lines.push(`Observed ${n.observedAt} local. Source: wttr.in`);
+  if (isAmbiguousLocation(w.query)) {
+    lines.push('The place name was ambiguous — TELL THE USER which location this is for, and '
+      + 'offer to re-check with a state or country if it is the wrong one.');
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Ask for one location's weather.
+ *
+ * @param fetchJson async (url, { timeoutMs }) -> parsed JSON. Injected, so the caller's
+ *        SSRF-guarded fetch is the only one that runs and this module stays runnable in Node,
+ *        a browser and a mobile runtime.
+ * @returns { ok: true, weather, text } | { ok: false, reason }
+ *
+ * NEVER THROWS. Every failure is a reason the caller can hand to the model as "use search
+ * instead", because an exception here would surface as a tool error and stop the turn on a
+ * question the fallback can still answer.
+ */
+export async function getWeather(location, { fetchJson, timeoutMs = WEATHER_TIMEOUT_MS, host = WEATHER_HOST } = {}) {
+  let url;
+  try { url = weatherUrl(location, { host }); } catch (e) { return { ok: false, reason: e.message }; }
+  if (typeof fetchJson !== 'function') return { ok: false, reason: 'no fetch was provided' };
+  let json;
+  try {
+    json = await fetchJson(url, { timeoutMs });
+  } catch (e) {
+    return { ok: false, reason: e?.message || 'the weather service did not answer' };
+  }
+  const weather = parseWeather(json, { query: location });
+  if (!weather) return { ok: false, reason: 'the weather service returned nothing usable' };
+  return { ok: true, weather, text: formatWeather(weather) };
+}