Fix alignment on Windows; auto-skip low-quality transcripts

Alignment Windows fixes:
- config.json read now uses encoding='utf-8' explicitly (avoids cp1252 crash)
- show_progress_bar=False in encode() avoids tqdm pipe-mode issues on Windows
- captions_dir.exists() guard before Path.glob() (Python 3.12 compat)
- get_embedder() wraps model load in try/except with helpful error message
- process_course() prints course/captions dir at startup for easier diagnosis
- All key print() calls have flush=True

Auto-detect wrong recordings:
- After transcription, compute words-per-minute; if < 50 words total or
  < 10 wpm → write quality='low' into caption JSON
- process_course() reads quality flag and skips low-quality captions with
  a clear [skip] message, preventing wasted embedding + alignment work
- Both local (faster-whisper) and API backends flag low-quality output

Author: nodeeeeee

electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-note",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "AutoNote — lecture notes generator from Canvas recordings",
   "main": "main.js",
   "scripts": {

extract_caption.py

@@ -352,12 +352,23 @@ def transcribe_api(video_path: Path, caption_path: Path) -> bool:
         "segments":             all_segments,
     }
 
+    n_seg  = len(all_segments)
+    n_word = sum(len(s["words"]) for s in all_segments)
+
+    # Quality check: flag likely wrong/empty recordings so alignment skips them
+    dur = total_dur or 1.0
+    wpm = (n_word / dur) * 60
+    if n_word < 50 or wpm < 10:
+        result["quality"] = "low"
+        print(f"  [warn] Very sparse transcript ({n_word} words, {wpm:.0f} wpm) — "
+              f"flagged as low quality, alignment will be skipped.")
+    else:
+        result["quality"] = "ok"
+
     caption_path.parent.mkdir(parents=True, exist_ok=True)
     with open(caption_path, "w", encoding="utf-8") as f:
         json.dump(result, f, ensure_ascii=False, indent=2)
 
-    n_seg  = len(result["segments"])
-    n_word = sum(len(s["words"]) for s in result["segments"])
     drop_note = f"  ({total_dropped} hallucinated segments removed)" if total_dropped else ""
     print(f"  Saved: {n_seg} segments / {n_word} words -> {caption_path}{drop_note}")
     return True
@@ -452,6 +463,20 @@ def transcribe_local(video_path: Path, caption_path: Path) -> bool:
 
     n_seg  = len(result["segments"])
     n_word = sum(len(s["words"]) for s in result["segments"])
+
+    # Quality check: flag likely wrong/empty recordings so alignment skips them
+    dur    = result["duration"] or 1.0
+    wpm    = (n_word / dur) * 60
+    if n_word < 50 or wpm < 10:
+        result["quality"] = "low"
+        print(f"  [warn] Very sparse transcript ({n_word} words, {wpm:.0f} wpm) — "
+              f"flagged as low quality, alignment will be skipped.")
+    else:
+        result["quality"] = "ok"
+
+    with open(caption_path, "w", encoding="utf-8") as f:
+        json.dump(result, f, ensure_ascii=False, indent=2)
+
     print(f"  Saved: {n_seg} segments / {n_word} words -> {caption_path}")
     return True
 

semantic_alignment.py

@@ -56,10 +56,11 @@
 
 # Course output directory: defaults to DATA_DIR but can be overridden by
 # OUTPUT_DIR in config.json so files land in the user's chosen Output Dir.
-_sa_config: dict = (
-    json.loads((DATA_DIR / "config.json").read_text())
-    if (DATA_DIR / "config.json").exists() else {}
-)
+try:
+    _cfg_file = DATA_DIR / "config.json"
+    _sa_config: dict = json.loads(_cfg_file.read_text(encoding="utf-8")) if _cfg_file.exists() else {}
+except Exception:
+    _sa_config = {}
 _out_dir = _sa_config.get("OUTPUT_DIR", "").strip()
 COURSE_DATA_DIR = Path(_out_dir) if _out_dir else DATA_DIR
 
@@ -393,21 +394,27 @@ def get_embedder():
     from sentence_transformers import SentenceTransformer
     import torch
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    print(f"  [embed] Loading {EMBED_MODEL} on {device} ...")
-    model = SentenceTransformer(EMBED_MODEL, device=device)
+    print(f"  [embed] Loading {EMBED_MODEL} on {device} ...", flush=True)
+    try:
+        model = SentenceTransformer(EMBED_MODEL, device=device)
+    except Exception as e:
+        print(f"  [embed] Failed to load model: {e}", flush=True)
+        raise
+    print(f"  [embed] Model loaded.", flush=True)
     return model
 
 
 def embed_texts(model, texts: list[str], desc: str = "  embedding") -> np.ndarray:
     """Return L2-normalised float32 embeddings, shape (N, D)."""
-    print(f"{desc} ({len(texts)} texts)…", flush=True)
+    print(f"{desc} ({len(texts)} texts)...", flush=True)
     vecs = model.encode(
         texts,
         batch_size=BATCH_SIZE,
-        show_progress_bar=True,
+        show_progress_bar=False,     # avoid tqdm issues in Windows pipe-mode subprocesses
         normalize_embeddings=True,   # cosine sim → inner product on unit sphere
         convert_to_numpy=True,
     )
+    print(f"{desc} done.", flush=True)
     return vecs.astype(np.float32)
 
 
@@ -1106,18 +1113,26 @@ def _content_match_slide_group(
 
 
 def process_course(course_id: int | str) -> None:
-    course_dir = COURSE_DATA_DIR / str(course_id)
-    captions   = sorted((course_dir / "captions").glob("*.json"))
+    course_dir  = COURSE_DATA_DIR / str(course_id)
+    captions_dir = course_dir / "captions"
+    print(f"Course dir : {course_dir}", flush=True)
+    print(f"Captions   : {captions_dir}", flush=True)
+
+    captions = sorted(captions_dir.glob("*.json")) if captions_dir.exists() else []
     all_slides = _candidate_slides(course_dir)
     out_dir    = course_dir / "alignment"
 
     if not captions:
-        print(f"No captions found in {course_dir}/captions/")
+        print(f"[warn] No captions found in {captions_dir}")
+        print("       Run 'Transcribe' first before aligning.")
         return
     if not all_slides:
-        print(f"No slide files found under {course_dir}/materials/")
+        print(f"[warn] No slide files found under {course_dir / 'materials'}")
+        print("       Run 'Download materials' first.")
         return
 
+    print(f"Found {len(captions)} caption(s), {len(all_slides)} slide file(s).", flush=True)
+
     # Group slide files by lecture number
     slides_by_num: dict[int, list[Path]] = defaultdict(list)
     for sp in all_slides:
@@ -1128,6 +1143,16 @@ def process_course(course_id: int | str) -> None:
     embedder = get_embedder()
 
     for cap in captions:
+        # Skip captions flagged as low-quality (wrong/empty recordings)
+        try:
+            with open(cap, encoding="utf-8") as _f:
+                _meta = json.load(_f)
+            if _meta.get("quality") == "low":
+                print(f"  [skip] Low-quality transcript (wrong/empty recording): {cap.name}")
+                continue
+        except Exception:
+            pass   # can't read → proceed and let align() handle it
+
         slide_group = _find_best_slide_group(cap, slides_by_num, all_slides)
         if not slide_group:
             slide_group = _content_match_slide_group(