@gotcos/glasses-server 6.46.1 → 6.47.0

package/server/lib/meeting-library-search.ts

@@ -19,6 +19,20 @@ import {
   resolveMeetingLibrary,
   sidecarSessionId,
 } from './cos-operations-meetings.js'
+import {
+  type ImportedMeetingLibrary,
+  type ImportedRecordKind,
+  IMPORTED_DOMAIN,
+  IMPORTED_FILENAME_PATTERN,
+  getImportedMeetingLibrary,
+  importRecordId,
+} from './imported-meeting-library.js'
+import {
+  type SupersededInputs,
+  importedLibraryMonths,
+  readDerivedRecords,
+  supersededInputsOf,
+} from './imported-library-rows.js'
 import { getMeetingStore, MeetingStore } from './meeting-store.js'
 import type { MeetingMeta } from './meeting-store.js'
 
@@ -67,6 +81,10 @@ export function libraryRefFromPath(filePath: string): { domain: string; month: s
   if (ops) return { domain: ops[1], month: ops[2], filename: ops[3] }
   const standalone = normalized.match(/\/recordings\/(\d{4}-\d{2})\/([^/]+\.md)$/i)
   if (standalone) return { domain: 'personal', month: standalone[1], filename: standalone[2] }
+  // BEFORE the direct-library shape, which is the bare `<month>/<file>.md` tail
+  // every one of these paths ends with and would otherwise claim them all.
+  const imports = normalized.match(/\/imports\/(\d{4}-\d{2})\/([^/]+\.md)$/i)
+  if (imports) return { domain: IMPORTED_DOMAIN, month: imports[1], filename: imports[2] }
   const direct = normalized.match(/\/(\d{4}-\d{2})\/([^/]+\.md)$/)
   if (direct) return { domain: 'library', month: direct[1], filename: direct[2] }
   return null
@@ -121,21 +139,89 @@ function sourceFrom(content: string): string {
   return match ? match[1].replace(/\s*\|?\s*$/, '').trim() : ''
 }
 
+/**
+ * The record id a hit opens.
+ *
+ * The imported and derived branches derive it from the FILENAME's hash rather
+ * than from the row, because a semantic hit arrives as a file path and has no
+ * row behind it. `importRecordId` is the one definition of that shape, shared
+ * with the library and the list, so a hit and a row can never name one record
+ * two different ways.
+ */
 function hitIdentity(row: {
   domain: string
   month: string
   filename: string
   librarySource?: MeetingMeta['librarySource']
   sessionId?: string
+  recordId?: string
 }): Pick<MeetingSearchHit, 'recordId' | 'month' | 'filename' | 'domain'> {
   const recordId = row.librarySource === 'direct_library'
     ? `direct:${row.month}:${row.filename}`
     : row.librarySource === 'standalone_recordings'
       ? `standalone:${row.sessionId || `${row.domain}:${row.month}:${row.filename}`}`
-      : `ops:${row.domain}:${row.month}:${row.filename}`
+      : row.librarySource === 'imported' || row.librarySource === 'blended'
+        ? row.recordId || importedRecordIdFromFilename(row.filename) || `ops:${row.domain}:${row.month}:${row.filename}`
+        : `ops:${row.domain}:${row.month}:${row.filename}`
   return { recordId, month: row.month, filename: row.filename, domain: row.domain }
 }
 
+/** `2026-09-10_merged_<h16>.md` names its own record. Null when it does not. */
+export function importedRecordIdFromFilename(filename: string): string | null {
+  const match = filename.match(IMPORTED_FILENAME_PATTERN)
+  if (!match) return null
+  return importRecordId(match[2] as ImportedRecordKind, match[3])
+}
+
+/**
+ * Keyword hits from the imported library.
+ *
+ * Runs BEFORE standalone and shares the same file budget, so a Mac with a large
+ * imported library cannot starve its own recordings of scan budget or the other
+ * way round. Supersession is applied by the caller, so one meeting gives one hit
+ * whether it is the import, the capture, or the merged record that matched.
+ */
+function keywordHitsFromImports(
+  tokens: string[],
+  domainFilter: string,
+  budget: { remaining: number },
+  library: ImportedMeetingLibrary = getImportedMeetingLibrary(),
+): MeetingSearchHit[] {
+  const hits: MeetingSearchHit[] = []
+  for (const month of importedLibraryMonths(library)) {
+    if (budget.remaining <= 0) break
+    for (const row of library.list({ month, domain: domainFilter })) {
+      if (budget.remaining <= 0) break
+      budget.remaining -= 1
+      let content = ''
+      try {
+        content = readFileSync(join(library.root, row.month, row.filename), 'utf8').slice(0, HEAD_BYTES)
+      } catch {
+        content = ''
+      }
+      const haystack = `${row.filename}\n${row.title}\n${row.originDomain}\n${content}`
+      const scored = scoreKeywordMatch(tokens, row.title, haystack)
+      if (scored.score <= 0) continue
+      hits.push({
+        recordId: row.recordId,
+        title: row.title,
+        date: row.date,
+        domain: row.domain,
+        duration: row.duration,
+        month: row.month,
+        filename: row.filename,
+        source: row.source,
+        librarySource: row.librarySource,
+        snippet: scored.snippet || row.title,
+        keywordScore: scored.score,
+        semanticScore: 0,
+        match: 'keyword',
+      })
+    }
+  }
+  return hits
+}
+
 function keywordHitsFromOps(tokens: string[], domainFilter: string, budget: { remaining: number }): MeetingSearchHit[] {
   const operationsDir = resolveCosOperationsDir()
   if (!operationsDir) return []
@@ -296,11 +382,55 @@ export function keywordSearchMeetings(
   if (library.layout === 'direct' && (domain === 'all' || domain === 'library')) {
     for (const hit of keywordHitsFromDirect(tokens, budget)) push(hit)
   }
+  // Imports before standalone, sharing one budget: a large imported library must
+  // not be scanned only after the recordings have spent the allowance, and the
+  // reverse must not happen either.
+  for (const hit of keywordHitsFromImports(tokens, domain, budget)) push(hit)
   for (const hit of keywordHitsFromStandalone(tokens, domain, budget, store)) push(hit)
-  return [...grouped.values()].sort((a, b) => b.keywordScore - a.keywordScore)
+  return dropSupersededHits([...grouped.values()]).sort((a, b) => b.keywordScore - a.keywordScore)
+}
+
+/**
+ * One meeting, one hit.
+ *
+ * A merged record contains the transcript of both its import and its capture, so
+ * a query that matches the meeting matches all three files. The list already
+ * drops the inputs a derived record holds; the search has to drop them too or
+ * the same conversation comes back three times under three titles.
+ *
+ * Only the imports root is consulted. On a Mac where the PIPELINE applied the
+ * merge there is nothing to drop: the merge was spliced into the Fireflies
+ * scribe in place and the capture's standalone scribe was retired, so only one
+ * file holds the meeting.
+ */
+export function dropSupersededHits(
+  hits: MeetingSearchHit[],
+  superseded: SupersededInputs = supersededInputsOf(readDerivedRecords()),
+): MeetingSearchHit[] {
+  if (superseded.isEmpty) return hits
+  return hits.filter(hit => {
+    if (hit.librarySource === 'blended') return true
+    if (superseded.importRecordIds.has(hit.recordId)) return false
+    if (hit.sessionId && superseded.g2Sessions.has(hit.sessionId)) return false
+    return true
+  })
 }
 
-interface SemanticRawHit {
+/**
+ * Which library a path belongs to.
+ *
+ * An imports path decides between `imported` and `blended` from the FILENAME's
+ * own kind, so a merged record found by semantic search is labelled the same way
+ * the list labels it rather than as a plain import.
+ */
+function librarySourceForRef(refDomain: string | undefined, filename: string): MeetingMeta['librarySource'] {
+  if (refDomain === 'library') return 'direct_library'
+  if (refDomain !== IMPORTED_DOMAIN) return 'cos_operations'
+  const match = filename.match(IMPORTED_FILENAME_PATTERN)
+  return match && match[2] !== 'fireflies' ? 'blended' : 'imported'
+}
+
+export interface SemanticRawHit {
   title?: string
   date?: string
   domain?: string
@@ -310,7 +440,16 @@ interface SemanticRawHit {
   meeting_id?: string
 }
 
-function semanticHitToLibrary(raw: SemanticRawHit): MeetingSearchHit | null {
+/**
+ * One semantic result as a library hit.
+ *
+ * Exported for the identity tests: a semantic hit arrives as a FILE PATH with no
+ * row behind it, so this is the only place where an imported or derived record's
+ * id has to be reconstructed from the filename. The keyword scan never exercises
+ * that branch, and an untested reconstruction is how a hit and a row end up
+ * naming one record two different ways.
+ */
+export function semanticHitToLibrary(raw: SemanticRawHit): MeetingSearchHit | null {
   const fromPath = raw.file_path ? libraryRefFromPath(raw.file_path) : null
   const domain = fromPath?.domain || raw.domain || ''
   const date = raw.date || ''
@@ -321,12 +460,8 @@ function semanticHitToLibrary(raw: SemanticRawHit): MeetingSearchHit | null {
   }
   if (!filename || !month) return null
   const title = raw.title || titleFrom('', filename)
-  const identity = hitIdentity({
-    domain: domain || 'quilt',
-    month,
-    filename,
-    librarySource: fromPath?.domain === 'library' ? 'direct_library' : 'cos_operations',
-  })
+  const librarySource = librarySourceForRef(fromPath?.domain, filename)
+  const identity = hitIdentity({ domain: domain || 'quilt', month, filename, librarySource })
   const semanticScore = typeof raw.score === 'number' && Number.isFinite(raw.score) ? Math.max(0, Math.min(1, raw.score)) : 0
   return {
     ...identity,
@@ -334,7 +469,7 @@ function semanticHitToLibrary(raw: SemanticRawHit): MeetingSearchHit | null {
     date,
     duration: '',
     source: '',
-    librarySource: identity.recordId.startsWith('direct:') ? 'direct_library' : 'cos_operations',
+    librarySource: identity.recordId.startsWith('direct:') ? 'direct_library' : librarySource,
     snippet: String(raw.summary || '').slice(0, 180),
     keywordScore: 0,
     semanticScore,

package/server/lib/meeting-parse.ts

@@ -0,0 +1,184 @@
+// The meeting markdown parser, shared by MeetingStore and the imported library.
+//
+// Moved out of meeting-store.ts in 6.47.0, unchanged. Imported records are the
+// same markdown shape as every other meeting record on this box, and the one
+// thing worse than two libraries would be two parsers: a field the importer
+// wrote and this parser read differently is a meeting that lists with the
+// wrong date and opens with the wrong duration.
+//
+// meeting-store.ts re-exports what it used to export, so every existing caller
+// and every existing test keeps its import path.
+
+import { basename } from 'node:path'
+import { FALLBACK_DOMAIN, domainAbbreviation } from './domains.js'
+import type { MeetingActionItem, MeetingDetail, MeetingMeta } from './meeting-store.js'
+
+export const MEETING_SOURCE_MAX_BYTES = 100_000
+export const DETAIL_CHUNK_ESTIMATE_CHARS = 1_700
+
+export function parseField(content: string, field: string): string {
+  const escaped = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const table = content.match(new RegExp(`\\*\\*${escaped}\\*\\*\\s*\\|\\s*(.+)`, 'i'))
+  if (table) return table[1].replace(/\s*\|?\s*$/, '').trim()
+  const plain = content.match(new RegExp(`\\*\\*${escaped}:\\*\\*\\s*(.+)`, 'i'))
+  return plain ? plain[1].trim() : ''
+}
+
+export function extractSection(content: string, headings: string[], toEnd = false): string {
+  for (const heading of headings) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const pattern = toEnd
+      ? new RegExp(`##\\s+${escaped}\\s*\\n([\\s\\S]*)$`, 'i')
+      : new RegExp(`##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, 'i')
+    const match = content.match(pattern)
+    if (match) return match[1].trim()
+  }
+  return ''
+}
+
+export function parseListSection(content: string, headings: string[], limit: number): string[] {
+  const section = extractSection(content, headings)
+  if (!section) return []
+  return section
+    .split('\n')
+    .filter(line => /^\s*[-*]\s+/.test(line))
+    .map(line => line.replace(/^\s*[-*]\s+/, '').trim())
+    .filter(Boolean)
+    .slice(0, limit)
+}
+
+export function parseActions(content: string): MeetingActionItem[] {
+  const section = extractSection(content, ['Action Items', 'Tasks', 'Next Steps'])
+  if (!section) return []
+  return section
+    .split('\n')
+    .filter(line => /^\s*(?:[-*]|\[[ xX]\])\s+/.test(line))
+    .map(line => {
+      const cleaned = line
+        .replace(/^\s*[-*]\s+/, '')
+        .replace(/^\[[ xX]\]\s*/, '')
+        .replace(/`\[REVIEW\]`\s*/i, '')
+        .trim()
+      const ownerMatch = cleaned.match(/\(\*\*(.+?)\*\*\)\s*$/)
+      return {
+        task: ownerMatch ? cleaned.replace(ownerMatch[0], '').trim() : cleaned,
+        owner: ownerMatch ? ownerMatch[1] : '',
+      }
+    })
+    .filter(item => item.task.length > 0)
+    .slice(0, 15)
+}
+
+export function parseAttendees(content: string): string[] {
+  return parseListSection(content, ['Attendees'], 20).map(line => {
+    const match = line.match(/^\*\*(.+?)\*\*/) || line.match(/^([^(]+)/)
+    return match ? match[1].trim() : line
+  })
+}
+
+export function parseDurationMinutes(duration: string): number | undefined {
+  if (!duration) return undefined
+  const value = duration.toLowerCase()
+  const colon = value.match(/\b(\d+):(\d{2})\b/)
+  if (colon) return Number(colon[1]) * 60 + Number(colon[2])
+  let total = 0
+  const hours = value.match(/(\d+(?:\.\d+)?)\s*(?:h|hr|hrs|hour|hours)\b/)
+  if (hours) total += Math.round(Number(hours[1]) * 60)
+  const minutes = value.match(/(\d+)\s*(?:m|min|mins|minute|minutes)\b/)
+  if (minutes) total += Number(minutes[1])
+  return total > 0 ? total : undefined
+}
+
+/** Return enough canonical source for grounded meeting follow-ups without
+ * allowing an unexpectedly large archive record to inflate every response.
+ * The boundary backs up over UTF-8 continuation bytes so the prefix never
+ * ends with a replacement character. */
+export function boundedMeetingSource(content: string): { sourceContent: string; sourceTruncated: boolean } {
+  const bytes = Buffer.from(content, 'utf8')
+  if (bytes.length <= MEETING_SOURCE_MAX_BYTES) return { sourceContent: content, sourceTruncated: false }
+  let end = MEETING_SOURCE_MAX_BYTES
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end -= 1
+  return { sourceContent: bytes.subarray(0, end).toString('utf8'), sourceTruncated: true }
+}
+
+export function parseMeeting(content: string, filename: string, month: string): MeetingDetail {
+  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim()
+  const date = parseField(content, 'Date') || filename.match(/^(\d{4}-\d{2}-\d{2})/)?.[1] || 'unknown'
+  const domain = parseField(content, 'Domain') || FALLBACK_DOMAIN
+  const duration = parseField(content, 'Duration')
+  const transcript = extractSection(content, ['Transcript'], true)
+  const storedSummary = extractSection(content, ['Summary'])
+  // A placeholder is not a summary. Until 6.37 this returned the TRANSCRIPT as
+  // the summary, which put the transcript in the summary slot on every surface
+  // and read as "the summary is broken" — the bug this replaces. The transcript
+  // is returned in its own `transcript` field and each surface renders it in
+  // its own section. An empty summary is the honest state, and every consumer
+  // already handles it: display-pages.ts falls back to 'No summary available.',
+  // and COS Control's Copy-summary button correctly disables on empty.
+  const summary = !storedSummary || /standalone recording|summary unavailable/i.test(storedSummary)
+    ? ''
+    : storedSummary
+  const topics = parseListSection(content, ['Topics Discussed'], 10)
+  const decisions = parseListSection(content, ['Decisions', 'Decisions Made'], 10)
+  const actionItems = parseActions(content)
+  const attendees = parseAttendees(content)
+  const source = boundedMeetingSource(content)
+
+  return {
+    filename,
+    title: heading || basename(filename, '.md').split('_').slice(1).join(' ') || 'Untitled Meeting',
+    date,
+    domain,
+    // Shared derivation. This was slice(0,2), which rendered sprocket_rocket as
+    // "SP" while cos-operations-meetings rendered it "SR" — two schemes in one
+    // codebase, disagreeing with each other.
+    domainAbbr: domainAbbreviation(domain),
+    source: parseField(content, 'Source'),
+    duration,
+    ...(parseDurationMinutes(duration) !== undefined ? { durationMinutes: parseDurationMinutes(duration) } : {}),
+    month,
+    summary,
+    topics,
+    decisions,
+    actionItems,
+    attendees,
+    transcript,
+    ...source,
+  }
+}
+
+export function toMeta(detail: MeetingDetail, sessionId?: string): MeetingMeta {
+  // Must mirror what the reader actually renders (display-pages.ts
+  // formatMeetingDetailBody), or the list row advertises a page count the
+  // reader does not honour. The transcript is part of that body since 6.37;
+  // omitting it here reported every standalone meeting as ~1p.
+  const detailCharEstimate = [
+    detail.title,
+    detail.date,
+    detail.duration || detail.source,
+    detail.summary,
+    detail.topics.join('\n'),
+    detail.decisions.join('\n'),
+    detail.actionItems.map(item => `${item.owner ? `[${item.owner}] ` : ''}${item.task}`).join('\n'),
+    detail.attendees.join(', '),
+    detail.transcript,
+  ].join('\n\n').trim().length
+  return {
+    filename: detail.filename,
+    ...(sessionId ? { sessionId } : {}),
+    title: detail.title,
+    date: detail.date,
+    domain: detail.domain,
+    domainAbbr: detail.domainAbbr,
+    source: detail.source,
+    duration: detail.duration,
+    ...(detail.durationMinutes !== undefined ? { durationMinutes: detail.durationMinutes } : {}),
+    month: detail.month,
+    detailCharEstimate,
+    estimatedDetailPages: Math.max(1, Math.ceil(detailCharEstimate / DETAIL_CHUNK_ESTIMATE_CHARS)),
+    topicCount: detail.topics.length,
+    decisionCount: detail.decisions.length,
+    actionCount: detail.actionItems.length,
+    attendeeCount: detail.attendees.length,
+  }
+}