fix(youtube): make video ingestion work on Postgres + extract transcripts

YouTube items silently produced no content on Postgres: the processor returns
item_type="video" but the ItemType enum (and thus the Postgres `itemtype` enum)
had no `video` member, so the write was rejected with InvalidTextRepresentation.
SQLite doesn't enforce enums, so this only ever failed in prod.

- add `video` to the ItemType enum + Alembic migration that ALTERs the Postgres
  enum (autocommit block; idempotent; no-op on SQLite)
- fetcher: roll back the session before recording _processing_error so a failed
  flush no longer raises PendingRollbackError and swallows the real error —
  this is why the failure left zero trace anywhere
- youtube: update transcript extraction to youtube-transcript-api v1.x
  (instance .list(); FetchedTranscript.to_raw_data()); the old static
  list_transcripts() was gone, so transcripts never extracted

Author: iota31

src/fourdpocket/db/migrations/versions/a7b8c9d0e1f2_add_video_itemtype.py

@@ -0,0 +1,36 @@
+"""add 'video' value to the itemtype enum
+
+The YouTube processor produces item_type="video", but the Postgres `itemtype`
+enum was created without it, so writing a YouTube item failed with
+InvalidTextRepresentation and the extraction was silently dropped. SQLite does
+not enforce enums, which is why this only surfaced on Postgres.
+
+Revision ID: a7b8c9d0e1f2
+Revises: f6a7b8c9d0e1
+Create Date: 2026-06-09 00:00:00.000000
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "a7b8c9d0e1f2"
+down_revision: Union[str, None] = "f6a7b8c9d0e1"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name != "postgresql":
+        # SQLite (and others) store enums as plain text — no type to alter.
+        return
+    # Postgres forbids ALTER TYPE ... ADD VALUE inside a transaction block,
+    # so run it in an autocommit block. IF NOT EXISTS keeps it idempotent.
+    with op.get_context().autocommit_block():
+        op.execute("ALTER TYPE itemtype ADD VALUE IF NOT EXISTS 'video'")
+
+
+def downgrade() -> None:
+    # Postgres has no supported way to drop an enum value; intentionally a no-op.
+    pass

src/fourdpocket/models/base.py

@@ -16,6 +16,7 @@ class ItemType(str, enum.Enum):
     image = "image"
     pdf = "pdf"
     code_snippet = "code_snippet"
+    video = "video"
 
 
 class SourcePlatform(str, enum.Enum):

src/fourdpocket/processors/youtube.py

@@ -132,7 +132,12 @@ async def process(self, url: str, **kwargs) -> ProcessorResult:
         try:
             from youtube_transcript_api import YouTubeTranscriptApi
             try:
-                tlist = YouTubeTranscriptApi.list_transcripts(video_id)
+                # youtube-transcript-api v1.x is instance-based (.list); older
+                # releases exposed a static list_transcripts(). Support both.
+                if hasattr(YouTubeTranscriptApi, "list_transcripts"):
+                    tlist = YouTubeTranscriptApi.list_transcripts(video_id)
+                else:
+                    tlist = YouTubeTranscriptApi().list(video_id)
                 t = None
                 try:
                     t = tlist.find_manually_created_transcript(["en"])
@@ -145,13 +150,27 @@ async def process(self, url: str, **kwargs) -> ProcessorResult:
                             break
                 if t:
                     fetched = t.fetch()
-                    for entry in fetched:
+                    # v1.x returns a FetchedTranscript of snippet objects;
+                    # to_raw_data() normalizes to the legacy list-of-dicts shape.
+                    entries = (
+                        fetched.to_raw_data()
+                        if hasattr(fetched, "to_raw_data")
+                        else fetched
+                    )
+                    for entry in entries:
                         if isinstance(entry, dict):
-                            transcript_segments.append({
-                                "text": entry.get("text", ""),
-                                "start": float(entry.get("start", 0.0)),
-                                "duration": float(entry.get("duration", 0.0)),
-                            })
+                            text = entry.get("text", "")
+                            start = entry.get("start", 0.0)
+                            duration = entry.get("duration", 0.0)
+                        else:
+                            text = getattr(entry, "text", "")
+                            start = getattr(entry, "start", 0.0)
+                            duration = getattr(entry, "duration", 0.0)
+                        transcript_segments.append({
+                            "text": text,
+                            "start": float(start),
+                            "duration": float(duration),
+                        })
                     metadata["transcript_language"] = t.language
                     metadata["transcript_auto_generated"] = t.is_generated
             except Exception as e:

src/fourdpocket/workers/fetcher.py

@@ -163,7 +163,17 @@ def fetch_and_process_url(item_id: str, url: str, user_id: str) -> dict:
 
         except Exception as e:
             logger.error("Failed to process item %s: %s", item_id, e)
-            item.item_metadata = {**item.item_metadata, "_processing_error": str(e)[:500]}
-            db.add(item)
-            db.commit()
+            # The failure may have left the session in a rolled-back state (e.g.
+            # a DataError mid-flush). Roll back first so recording the error
+            # doesn't itself raise PendingRollbackError and swallow the failure.
+            db.rollback()
+            try:
+                item = db.get(KnowledgeItem, uuid.UUID(item_id))
+                if item is not None:
+                    item.item_metadata = {**item.item_metadata, "_processing_error": str(e)[:500]}
+                    db.add(item)
+                    db.commit()
+            except Exception as record_err:
+                logger.error("Failed to record processing error for %s: %s", item_id, record_err)
+                db.rollback()
             return {"status": "error", "error": str(e)[:500]}