@chatpanel/events 0.67.0 → 0.68.0

package/index.js

@@ -273,3 +273,6 @@ export { renderMarkdown, defaultLinkPolicy } from './markdown-render.js';
 // extension writes and MCP reads, so every client shows one transcript, not three.
 export { parseMeetingText, speakerStats, densityRibbon } from './meeting-text.js';
 export { speakerBreakdown, speakerTimeline, formatTalkTime, SPEAKER_SLOTS } from './meeting-shape.js';
+// A list of records as a person reads it, and what a meeting settled — both read, never derived.
+export { SORT_MODES, SORT_LABELS, sortStamp, sortRecords, filterRecords, dayBucket, rowTime, groupRecords } from './record-list.js';
+export { INSIGHT_KINDS, summarySections, insightKindOf, meetingInsights, hasInsights } from './meeting-insights.js';

package/meeting-insights.js

@@ -0,0 +1,62 @@
+// What a meeting settled, asked for and left open — read out of the summary it already has.
+//
+// The extension writes a meeting's summary as markdown with headings: "## Decisions",
+// "## Action items", "## Open questions", whatever the model chose to call them. A client that
+// wants an Insights view should not re-derive that with a second model call; the sections
+// are there, and one parser that recognises the headings is the same on every client.
+//
+// Pure, forgiving of wording: a heading is matched by what it MEANS ("Decisions", "Agreed",
+// "Outcomes" are one thing), bullets in any marker, numbered or not.
+
+const KINDS = Object.freeze([
+  { id: 'decisions', label: 'Decisions', re: /\b(decision|decided|agreed|agreement|outcome|resolution)s?\b/i },
+  { id: 'actions', label: 'Action items', re: /\b(action|todo|to-do|next step|follow[- ]?up|task|owner)s?\b/i },
+  { id: 'questions', label: 'Open questions', re: /\b(question|open item|unresolved|blocker|risk)s?\b/i },
+]);
+
+export const INSIGHT_KINDS = Object.freeze(KINDS.map((k) => ({ id: k.id, label: k.label })));
+
+/** Split markdown into `[{ heading, level, items, text }]` on its headings. */
+export function summarySections(markdown) {
+  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
+  const out = [];
+  let cur = { heading: '', level: 0, items: [], text: '' };
+  const push = () => { if (cur.heading || cur.items.length || cur.text.trim()) out.push({ ...cur, text: cur.text.trim() }); };
+  for (const raw of lines) {
+    const h = /^\s{0,3}(#{1,6})\s+(.+?)\s*#*\s*$/.exec(raw);
+    if (h) { push(); cur = { heading: h[2].trim(), level: h[1].length, items: [], text: '' }; continue; }
+    const b = /^\s*(?:[-*•]|\d+[.)])\s+(.+?)\s*$/.exec(raw);
+    if (b) { cur.items.push(b[1]); continue; }
+    if (raw.trim()) cur.text += (cur.text ? '\n' : '') + raw.trim();
+  }
+  push();
+  return out;
+}
+
+/** Which insight a heading names, or null for a section that is neither. */
+export function insightKindOf(heading) {
+  const h = String(heading || '');
+  for (const k of KINDS) if (k.re.test(h)) return k.id;
+  return null;
+}
+
+/**
+ * `{ decisions, actions, questions, other }` — each a list of `{ text, section }`; `other`
+ * keeps the sections that were none of the three, so a view can still show them.
+ */
+export function meetingInsights(markdown) {
+  const out = { decisions: [], actions: [], questions: [], other: [] };
+  for (const s of summarySections(markdown)) {
+    const kind = insightKindOf(s.heading);
+    const items = s.items.length ? s.items : (s.text ? s.text.split('\n') : []);
+    if (!kind) { if (s.heading || items.length) out.other.push(s); continue; }
+    for (const text of items) out[kind].push({ text, section: s.heading });
+  }
+  return out;
+}
+
+/** True when the summary has at least one insight worth a tab. */
+export function hasInsights(markdown) {
+  const i = meetingInsights(markdown);
+  return i.decisions.length + i.actions.length + i.questions.length > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.67.0",
+  "version": "0.68.0",
   "description": "The canonical ChatPanel event-log and capability contracts \u2014 typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",
@@ -98,7 +98,9 @@
     "./toolset.js": "./toolset.js",
     "./tool-dispatch.js": "./tool-dispatch.js",
     "./find-tool.js": "./find-tool.js",
-    "./web-search-tool.js": "./web-search-tool.js"
+    "./web-search-tool.js": "./web-search-tool.js",
+    "./record-list.js": "./record-list.js",
+    "./meeting-insights.js": "./meeting-insights.js"
   },
   "files": [
     "LICENSE",
@@ -131,6 +133,7 @@
     "mcp-errors.js",
     "media-transcript.js",
     "meeting-analyzers.js",
+    "meeting-insights.js",
     "meeting-shape.js",
     "meeting-text.js",
     "memory.js",
@@ -149,6 +152,7 @@
     "queue.js",
     "reach.js",
     "recipe.js",
+    "record-list.js",
     "redaction-tokens.js",
     "ref.js",
     "registry.js",

package/record-list.js

@@ -0,0 +1,110 @@
+// A list of records as a person reads it: which order, which ones, and under which heading.
+//
+// The desktop showed 300 rows newest-modified-first with a date and nothing else, and it read
+// as unsorted — twelve rows saying "Sep 12" are indistinguishable, "modified" is not the
+// date a person remembers a chat by, and nothing separated today from last month. The query
+// was right; the reading was impossible. These are the rules that make the same rows
+// legible, kept out of the client because every list of records — the extension's history,
+// a phone's — has to answer the same three questions the same way.
+//
+// Pure: `now` is injected, and a record needs only `{ title, snippet?, updatedAt, createdAt }`.
+
+export const SORT_MODES = Object.freeze(['recent', 'started', 'title']);
+
+export const SORT_LABELS = Object.freeze({
+  recent: 'Recently active',
+  started: 'Date started',
+  title: 'Title A–Z',
+});
+
+const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+
+/** The timestamp a sort mode reads — modified for `recent`, created for `started`. */
+export function sortStamp(rec, mode = 'recent') {
+  if (mode === 'started') return num(rec?.createdAt) || num(rec?.updatedAt);
+  return num(rec?.updatedAt) || num(rec?.createdAt);
+}
+
+export function sortRecords(items, mode = 'recent') {
+  const list = Array.isArray(items) ? [...items] : [];
+  if (mode === 'title') {
+    return list.sort((a, b) => String(a?.title || '').localeCompare(String(b?.title || ''), undefined, { sensitivity: 'base' }) || sortStamp(b) - sortStamp(a));
+  }
+  const m = SORT_MODES.includes(mode) ? mode : 'recent';
+  return list.sort((a, b) => sortStamp(b, m) - sortStamp(a, m));
+}
+
+/**
+ * Keep the rows every word of the query appears in — title or snippet, any order, any case.
+ * A query of nothing keeps everything, so a filter box can be bound to it directly.
+ */
+export function filterRecords(items, query) {
+  const words = String(query || '').toLowerCase().split(/\s+/).filter(Boolean);
+  const list = Array.isArray(items) ? items : [];
+  if (!words.length) return list;
+  return list.filter((r) => {
+    const hay = `${r?.title || ''}\n${r?.snippet || ''}`.toLowerCase();
+    return words.every((w) => hay.includes(w));
+  });
+}
+
+const DAY = 86_400_000;
+
+function startOfDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+/** Which heading a timestamp files under, relative to `now`. */
+export function dayBucket(ts, now = Date.now()) {
+  const t = num(ts);
+  if (!t) return { key: 'undated', label: 'Undated', order: 9e15 };
+  const today = startOfDay(now);
+  const day = startOfDay(t);
+  const daysAgo = Math.round((today - day) / DAY);
+  if (daysAgo <= 0) return { key: 'today', label: 'Today', order: 0 };
+  if (daysAgo === 1) return { key: 'yesterday', label: 'Yesterday', order: 1 };
+  if (daysAgo < 7) return { key: 'week', label: 'Earlier this week', order: 2 };
+  const d = new Date(t);
+  const n = new Date(now);
+  if (d.getFullYear() === n.getFullYear() && d.getMonth() === n.getMonth()) return { key: 'month', label: 'Earlier this month', order: 3 };
+  const label = d.getFullYear() === n.getFullYear() ? MONTHS[d.getMonth()] : `${MONTHS[d.getMonth()]} ${d.getFullYear()}`;
+  return { key: `m-${d.getFullYear()}-${d.getMonth()}`, label, order: 4 + (n.getFullYear() * 12 + n.getMonth()) - (d.getFullYear() * 12 + d.getMonth()) };
+}
+
+/**
+ * The time a row shows, sized to how far away it is: a clock today and yesterday, a weekday
+ * this week, a short date after that. Inside a day group the clock is the only thing that
+ * tells two rows apart — which is the whole reason the desktop's list looked unsorted.
+ */
+export function rowTime(ts, now = Date.now(), { locale = undefined } = {}) {
+  const t = num(ts);
+  if (!t) return '';
+  const b = dayBucket(t, now);
+  const d = new Date(t);
+  if (b.key === 'today' || b.key === 'yesterday') return d.toLocaleTimeString(locale, { hour: 'numeric', minute: '2-digit' });
+  if (b.key === 'week') return DAYS[d.getDay()];
+  const sameYear = d.getFullYear() === new Date(now).getFullYear();
+  return d.toLocaleDateString(locale, { month: 'short', day: 'numeric', ...(sameYear ? {} : { year: 'numeric' }) });
+}
+
+/**
+ * Sort, filter and group in one pass: `[{ key, label, items }]`, groups in reading order.
+ * With `mode: 'title'` there is one group and no heading, because an alphabetical list has
+ * nothing to do with days.
+ */
+export function groupRecords(items, { mode = 'recent', query = '', now = Date.now() } = {}) {
+  const sorted = sortRecords(filterRecords(items, query), mode);
+  if (mode === 'title') return sorted.length ? [{ key: 'all', label: '', items: sorted }] : [];
+  const groups = new Map();
+  for (const r of sorted) {
+    const b = dayBucket(sortStamp(r, mode), now);
+    if (!groups.has(b.key)) groups.set(b.key, { key: b.key, label: b.label, order: b.order, items: [] });
+    groups.get(b.key).items.push(r);
+  }
+  return [...groups.values()].sort((a, b) => a.order - b.order).map(({ order, ...g }) => g);
+}