Intelligent auto-matching: multi-strategy scoring for video-slide pairs

Replaces naive token-overlap matching with a scored multi-strategy system:
1. Lecture number match (Week3 → L3, Lec2 → L2)           +100 pts
2. Date match (video "06/03/2026" → slide "ann060326")     +80 pts
3. Filename token overlap (Jaccard similarity)             +0..30 pts
4. Transcript keyword overlap with slide filename          +10 per hit
5. Slide version preference ("With notes" +5, "Review" +3, annotated +2)
6. Lecture subfolder preference                            +2 pts

Server-side computation (main.js) reads transcript content for keyword
extraction. Suggestions attached to scan results so the renderer just
uses them. Both Electron and Flet GUIs updated.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nodeeeeee

electron/main.js

@@ -841,6 +841,95 @@ function registerIpc() {
       try { mapping = JSON.parse(fs.readFileSync(mapFile, 'utf8')); } catch {}
     }
 
+    // ── Smart auto-suggest for each caption ──────────────────────────────────
+    // Strategy: lecture-number match → date match → transcript keyword overlap
+    function autoSuggest(capStem) {
+      const cl = capStem.toLowerCase().replace(/[-_]/g, ' ');
+
+      // 1. Extract number from caption: Week3, Lec2, L5, etc.
+      const numMatch = cl.match(/week\s*(\d+)|lec(?:ture)?\s*(\d+)|\bl(\d+)\b/);
+      const capNum = numMatch ? (numMatch[1] || numMatch[2] || numMatch[3]) : null;
+
+      // 2. Extract date from caption: "06/03/2026" or "06_03_2026"
+      const dateMatch = capStem.match(/(\d{2})[/_](\d{2})[/_](\d{4})/);
+      const capDate = dateMatch ? dateMatch[1] + dateMatch[2] + dateMatch[3].slice(2) : null;
+
+      // 3. Read first few lines of transcript for keyword extraction
+      let capKeywords = new Set();
+      const capFile = path.join(capDir, capStem + '.json');
+      if (fs.existsSync(capFile)) {
+        try {
+          const capData = JSON.parse(fs.readFileSync(capFile, 'utf8'));
+          const segs = capData.segments || [];
+          // Sample ~20 segments evenly for topic keywords
+          const step = Math.max(1, Math.floor(segs.length / 20));
+          const words = segs.filter((_, i) => i % step === 0)
+            .map(s => s.text || '').join(' ').toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '').split(/\s+/)
+            .filter(w => w.length > 4);
+          capKeywords = new Set(words);
+        } catch {}
+      }
+
+      let bestScore = 0;
+      let bestSlide = null;
+
+      for (const s of slides) {
+        const sl = s.name.toLowerCase().replace(/[-_]/g, ' ');
+        let score = 0;
+
+        // Strategy 1: Lecture number match
+        const slNumMatch = sl.match(/l(?:ecture)?\s*(\d+)/);
+        if (capNum && slNumMatch && capNum === slNumMatch[1]) {
+          score += 100;
+        }
+
+        // Strategy 2: Date match (video date → slide annotation date)
+        // e.g. "06/03/2026" matches "ann060326" in slide filename
+        if (capDate) {
+          if (sl.includes(capDate) || s.name.includes(capDate)) {
+            score += 80;
+          }
+        }
+
+        // Strategy 3: Token overlap between caption stem and slide name
+        const capTokens = new Set(cl.split(/\s+/).filter(t => t.length > 1));
+        const slTokens = new Set(sl.split(/\s+/).filter(t => t.length > 1));
+        const inter = [...capTokens].filter(t => slTokens.has(t)).length;
+        if (capTokens.size && slTokens.size) {
+          score += (inter / Math.max(capTokens.size, slTokens.size)) * 30;
+        }
+
+        // Strategy 4: Transcript keyword overlap with slide filename words
+        if (capKeywords.size > 0) {
+          const slWords = sl.replace(/[^a-z0-9\s]/g, '').split(/\s+/).filter(w => w.length > 4);
+          const kwHits = slWords.filter(w => capKeywords.has(w)).length;
+          score += kwHits * 10;
+        }
+
+        // Preference: "with notes" > "review" > annotated > plain
+        if (/with\s*notes/i.test(s.name)) score += 5;
+        else if (/review/i.test(s.name)) score += 3;
+        else if (/ann\d/i.test(s.name)) score += 2;
+
+        // Preference: files in a "Lectures" subfolder
+        if (/lecture/i.test(s.rel)) score += 2;
+
+        if (score > bestScore) {
+          bestScore = score;
+          bestSlide = s.rel;
+        }
+      }
+
+      return { suggested: bestScore > 5 ? bestSlide : null, score: bestScore };
+    }
+
+    // Attach suggestions to captions
+    for (const cap of captions) {
+      const { suggested } = autoSuggest(cap.stem);
+      cap.suggested = suggested;
+    }
+
     return { captions, slides, titles, mapping, base };
   });
 

electron/renderer/app.js

@@ -673,29 +673,9 @@ function _alignSlideOptionsHtml(selected = '(none)') {
   return html;
 }
 
-function _alignAutoSuggest(capStem) {
-  // Simple heuristic: week number → lecture number, or token overlap
-  const capLower = capStem.toLowerCase().replace(/[-_]/g, ' ');
-  const weekMatch = capLower.match(/week\s*(\d+)/);
-  const lecMatch  = capLower.match(/lec(?:ture)?\s*(\d+)/);
-  const capNum    = weekMatch ? weekMatch[1] : (lecMatch ? lecMatch[1] : null);
-
-  let bestScore = 0, bestRel = '';
-  for (const s of AlignState.slideOptions) {
-    const sl = s.name.toLowerCase().replace(/[-_]/g, ' ');
-    // Lecture number match
-    const slNum = sl.match(/l(?:ecture)?\s*(\d+)/i);
-    if (capNum && slNum && capNum === slNum[1]) return s.rel;
-    // Token overlap
-    const capTokens = new Set(capLower.split(/\s+/));
-    const slTokens  = new Set(sl.split(/\s+/));
-    const inter = [...capTokens].filter(t => slTokens.has(t)).length;
-    const union = new Set([...capTokens, ...slTokens]).size;
-    const score = union ? inter / union : 0;
-    if (score > bestScore) { bestScore = score; bestRel = s.rel; }
-  }
-  return bestScore > 0.05 ? bestRel : '(none)';
-}
+// Auto-suggest is now computed server-side in main.js (align:scan handler)
+// using lecture-number matching, date matching, transcript keyword overlap,
+// and slide version preferences (with notes > review > plain).
 
 function _alignRebuildRows() {
   const container = document.getElementById('align-match-rows');
@@ -1469,10 +1449,10 @@ async function attachPageHandlers() {
         if (data.mapping[cap.stem] && data.mapping[cap.stem].length) {
           initSlides = data.mapping[cap.stem];
         } else {
-          const suggested = _alignAutoSuggest(cap.stem);
-          initSlides = suggested !== '(none)' ? [suggested] : ['(none)'];
+          // Use server-side suggestion (computed with transcript keywords + date matching)
+          initSlides = cap.suggested ? [cap.suggested] : ['(none)'];
         }
-        return { stem: cap.stem, title, aligned: cap.aligned, slides: initSlides };
+        return { stem: cap.stem, title, aligned: cap.aligned, transcribed: cap.transcribed, slides: initSlides };
       });
 
       _alignRebuildRows();

gui.py

@@ -1229,32 +1229,80 @@ def build_align(page: ft.Page, console: OutputConsole) -> ft.Column:
     # State:  rows = [ {stem, title, aligned, container, slide_dropdowns: [dd,...]} ]
     _match_state: dict = {"rows": [], "base": None, "slide_opts": []}
 
-    def _auto_suggest(cap_stem: str, slides: list, base: Path) -> list[str]:
-        """Find auto-matched slides for a caption. Returns list of rel paths."""
+    def _auto_suggest(cap_stem: str, slides: list, base: Path,
+                      cap_dir: Path | None = None) -> list[str]:
+        """Find auto-matched slides for a caption using multi-strategy scoring.
+
+        Strategies (scored and summed):
+          1. Lecture number match (Week3 → L3)      — +100
+          2. Date match (06/03/2026 → ann060326)    — +80
+          3. Filename token overlap                  — +0..30
+          4. Transcript keyword overlap with slide   — +10 per hit
+          5. Preference: "with notes" > "review"     — +5/+3/+2
+        """
         import re as _re
-        results: list[str] = []
-        cap_lower = cap_stem.lower().replace("-", " ").replace("_", " ")
-        cap_tokens = set(cap_lower.split())
+        cl = cap_stem.lower().replace("-", " ").replace("_", " ")
+
+        # Extract number from caption
+        num_m = _re.search(r"week\s*(\d+)|lec(?:ture)?\s*(\d+)|\bl(\d+)\b", cl)
+        cap_num = (num_m.group(1) or num_m.group(2) or num_m.group(3)) if num_m else None
+
+        # Extract date from caption (e.g. "06_03_2026")
+        date_m = _re.search(r"(\d{2})[/_](\d{2})[/_](\d{4})", cap_stem)
+        cap_date = (date_m.group(1) + date_m.group(2) + date_m.group(3)[2:]) if date_m else None
+
+        # Read transcript keywords
+        cap_keywords: set[str] = set()
+        if cap_dir:
+            cap_file = cap_dir / f"{cap_stem}.json"
+            if cap_file.exists():
+                try:
+                    import json as _json
+                    segs = _json.loads(cap_file.read_text()).get("segments", [])
+                    step = max(1, len(segs) // 20)
+                    words = " ".join(s.get("text", "") for s in segs[::step][:20]).lower()
+                    cap_keywords = {w for w in _re.findall(r"[a-z]{5,}", words)}
+                except Exception:
+                    pass
+
         best_score, best_rel = 0.0, ""
         for sp in slides:
             sl = sp.stem.lower().replace("-", " ").replace("_", " ")
-            sl_tokens = set(sl.split())
-            if cap_tokens and sl_tokens:
-                score = len(cap_tokens & sl_tokens) / len(cap_tokens | sl_tokens)
-                if score > best_score:
-                    best_score = score
-                    best_rel = str(sp.relative_to(base))
-            cap_num = _re.search(r"week\s*(\d+)|lec(?:ture)?\s*(\d+)|[Ll](\d+)", cap_stem)
-            sl_num  = _re.search(r"[Ll](?:ecture)?\s*(\d+)", sp.stem)
-            if cap_num and sl_num:
-                cn = next(g for g in cap_num.groups() if g)
-                sn = sl_num.group(1)
-                if cn == sn:
-                    best_rel = str(sp.relative_to(base))
-                    best_score = 1.0
-        if best_score > 0.05 and best_rel:
-            results.append(best_rel)
-        return results
+            score = 0.0
+
+            # Strategy 1: lecture number
+            sl_num_m = _re.search(r"l(?:ecture)?\s*(\d+)", sl)
+            if cap_num and sl_num_m and cap_num == sl_num_m.group(1):
+                score += 100
+
+            # Strategy 2: date match
+            if cap_date and cap_date in sp.name:
+                score += 80
+
+            # Strategy 3: token overlap
+            ct = set(cl.split())
+            st = set(sl.split())
+            if ct and st:
+                score += (len(ct & st) / max(len(ct), len(st))) * 30
+
+            # Strategy 4: transcript keyword overlap
+            if cap_keywords:
+                sl_words = set(_re.findall(r"[a-z]{5,}", sl))
+                score += len(cap_keywords & sl_words) * 10
+
+            # Strategy 5: prefer annotated versions
+            if _re.search(r"with\s*notes", sp.name, _re.IGNORECASE):
+                score += 5
+            elif _re.search(r"review", sp.name, _re.IGNORECASE):
+                score += 3
+            elif _re.search(r"ann\d", sp.name, _re.IGNORECASE):
+                score += 2
+
+            if score > best_score:
+                best_score = score
+                best_rel = str(sp.relative_to(base))
+
+        return [best_rel] if best_score > 5 and best_rel else []
 
     def _make_slide_dropdown(initial: str = "(none)") -> ft.Dropdown:
         """Create a single slide-file dropdown."""
@@ -1465,7 +1513,7 @@ def _scan_matching(_) -> None:
                 if not initials:
                     initials = ["(none)"]
             else:
-                initials = _auto_suggest(cap.stem, slides, base)
+                initials = _auto_suggest(cap.stem, slides, base, cap_dir)
                 if not initials:
                     initials = ["(none)"]