opencode-skills-collection 3.1.0 → 3.1.2

package/bundled-skills/youtube-notetaker/scripts/serve.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Standalone viewer + API server for a YouTube deep-dive library.
+
+Zero framework dependencies (Python stdlib + PyYAML). It serves the interactive
+artifact and a small read/write API over a plain folder of markdown files, so the
+whole thing runs anywhere with no custom backend.
+
+  python3 serve.py [--dir LIBRARY] [--port 8000] [--artifact path/to/artifact.html]
+
+LIBRARY defaults to $VIDEO_LIBRARY_DIR or ~/video-deepdives. Layout:
+  LIBRARY/<YTID>.md                     one markdown file per video (frontmatter + transcript)
+  LIBRARY/_media/<YTID>-slide-NN.jpg    slide images
+
+Routes (the artifact talks to these; the /api/video-deepdives namespace is
+arbitrary and kept only so the same artifact HTML works unmodified):
+  GET   /                                       the artifact (single-page app)
+  GET   /api/video-deepdives              list every video (flattened frontmatter)
+  GET   /api/video-deepdives/<id>         one video: {meta, body}
+  GET   /api/video-deepdives/_media/<f>   a slide image
+  PATCH /api/video-deepdives/<id>         merge {fields:{...}} into frontmatter, rewrite
+"""
+import argparse, json, os, sys, re, mimetypes, posixpath
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+try:
+    import yaml
+except ImportError:
+    sys.exit("pip install pyyaml")
+
+API = "/api/video-deepdives"
+FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.DOTALL)
+SAFE_SLUG_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+SAFE_MEDIA_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+SAFE_CTYPE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*(?:; charset=[A-Za-z0-9._-]+)?$")
+
+
+def split_frontmatter(text):
+    """Return (meta_dict, body_str) from a markdown file with YAML frontmatter."""
+    m = FM_RE.match(text)
+    if not m:
+        return {}, text
+    meta = yaml.safe_load(m.group(1)) or {}
+    return meta, m.group(2)
+
+
+def dump_file(meta, body):
+    out = "---\n" + yaml.safe_dump(meta, sort_keys=False, allow_unicode=True, width=100) + "---\n"
+    return out + body
+
+
+def library_path(lib, *parts):
+    root = Path(lib).resolve()
+    candidate = root.joinpath(*parts).resolve()
+    try:
+        candidate.relative_to(root)
+    except ValueError:
+        return None
+    return candidate
+
+
+def safe_content_type(ctype):
+    return ctype if isinstance(ctype, str) and SAFE_CTYPE_RE.match(ctype) else "application/octet-stream"
+
+
+def load_item(lib, slug):
+    if not SAFE_SLUG_RE.match(slug):
+        return None
+    path = library_path(lib, slug + ".md")
+    if not path or not path.is_file():
+        return None
+    meta, body = split_frontmatter(path.read_text(encoding="utf-8"))
+    return path, meta, body
+
+
+def list_items(lib):
+    items = []
+    for path in sorted(Path(lib).iterdir()):
+        fn = path.name
+        if not path.is_file() or not fn.endswith(".md") or fn.startswith("_"):
+            continue
+        slug = path.stem
+        loaded = load_item(lib, slug)
+        if not loaded:
+            continue
+        _, meta, body = loaded
+        it = dict(meta)
+        it["slug"] = slug
+        it["file"] = fn
+        it["preview"] = body.strip()[:160]
+        items.append(it)
+    return items
+
+
+class Handler(BaseHTTPRequestHandler):
+    lib = None
+    artifact = None
+    write_token = None
+
+    def log_message(self, *a):
+        pass  # quiet
+
+    def _send(self, code, body, ctype="application/json"):
+        ctype = safe_content_type(ctype)
+        if isinstance(body, (dict, list)):
+            body = json.dumps(body).encode()
+        elif isinstance(body, str):
+            body = body.encode()
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type, X-Video-Library-Token")
+        self.end_headers()
+        if self.command != "HEAD":
+            self.wfile.write(body)
+
+    def do_OPTIONS(self):
+        self._send(204, b"")
+
+    def do_GET(self):
+        path = self.path.split("?", 1)[0].rstrip("/") or "/"
+        if path in ("/", "/index.html"):
+            try:
+                return self._send(200, open(self.artifact, encoding="utf-8").read(), "text/html; charset=utf-8")
+            except OSError:
+                return self._send(500, {"error": "artifact not found: " + self.artifact})
+
+        if path == API:
+            items = list_items(self.lib)
+            return self._send(200, {"collection": "video-deepdives", "total": len(items), "items": items})
+
+        if path.startswith(API + "/_media/"):
+            fn = posixpath.basename(path)  # strip any traversal
+            if not SAFE_MEDIA_RE.match(fn):
+                return self._send(400, {"error": "bad media name"})
+            fp = library_path(self.lib, "_media", fn)
+            if not fp or not fp.is_file():
+                return self._send(404, {"error": "no such media"})
+            ctype = mimetypes.guess_type(str(fp))[0] or "application/octet-stream"
+            return self._send(200, fp.read_bytes(), ctype)
+
+        if path.startswith(API + "/"):
+            slug = posixpath.basename(path)
+            loaded = load_item(self.lib, slug)
+            if not loaded:
+                return self._send(404, {"error": "no such item"})
+            _, meta, body = loaded
+            return self._send(200, {"slug": slug, "type": "video-deepdive", "meta": meta, "body": body.rstrip("\n")})
+
+        return self._send(404, {"error": "not found"})
+
+    def do_PATCH(self):
+        if not self.write_token:
+            return self._send(403, {"error": "writes disabled"})
+        if self.headers.get("X-Video-Library-Token") != self.write_token:
+            return self._send(403, {"error": "bad write token"})
+        path = self.path.split("?", 1)[0].rstrip("/")
+        if not path.startswith(API + "/"):
+            return self._send(404, {"error": "not found"})
+        slug = posixpath.basename(path)
+        loaded = load_item(self.lib, slug)
+        if not loaded:
+            return self._send(404, {"error": "no such item"})
+        fp, meta, body = loaded
+        try:
+            n = int(self.headers.get("Content-Length", 0))
+            payload = json.loads(self.rfile.read(n) or b"{}")
+        except (ValueError, json.JSONDecodeError):
+            return self._send(400, {"error": "bad json"})
+        fields = payload.get("fields", payload)  # accept {fields:{...}} or a bare dict
+        if not isinstance(fields, dict):
+            return self._send(400, {"error": "fields must be an object"})
+        meta.update(fields)
+        fp.write_text(dump_file(meta, body), encoding="utf-8")
+        return self._send(200, {"ok": True, "slug": slug, "updated": list(fields.keys())})
+
+
+def self_test():
+    with TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        (root / "video_1.md").write_text("---\ntitle: Demo\n---\nBody", encoding="utf-8")
+        (root / "_media").mkdir()
+        (root / "_media" / "video_1-slide-01.jpg").write_bytes(b"x")
+        assert load_item(str(root), "video_1")
+        assert load_item(str(root), "../secret") is None
+        assert library_path(str(root), "_media", "../video_1.md") == root.resolve() / "video_1.md"
+        assert safe_content_type("text/html; charset=utf-8") == "text/html; charset=utf-8"
+        assert safe_content_type("text/html\r\nX-Bad: 1") == "application/octet-stream"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--self-test", action="store_true")
+    ap.add_argument("--dir", default=os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives")))
+    ap.add_argument("--port", type=int, default=int(os.environ.get("VIDEO_LIBRARY_PORT", "8000")))
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--write-token", default=os.environ.get("VIDEO_LIBRARY_WRITE_TOKEN"))
+    here = os.path.dirname(os.path.abspath(__file__))
+    ap.add_argument("--artifact", default=os.path.join(here, "..", "reference", "artifact.html"))
+    a = ap.parse_args()
+    if a.self_test:
+        self_test()
+        return
+
+    lib = os.path.abspath(os.path.expanduser(a.dir))
+    os.makedirs(lib, exist_ok=True)
+    Handler.lib = lib
+    Handler.artifact = os.path.abspath(a.artifact)
+    Handler.write_token = a.write_token
+    n = len([f for f in os.listdir(lib) if f.endswith(".md") and not f.startswith("_")])
+    print(f"Library: {lib}  ({n} videos)")
+    print(f"Artifact: {Handler.artifact}")
+    print("Writes: " + ("enabled with X-Video-Library-Token" if Handler.write_token else "disabled (set VIDEO_LIBRARY_WRITE_TOKEN to enable PATCH)"))
+    print(f"Serving on http://{a.host}:{a.port}/   (Ctrl-C to stop)")
+    ThreadingHTTPServer((a.host, a.port), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/youtube-notetaker/scripts/setup.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Resolve a YouTube id from a URL/id, print the scratch dir, and report embeddability.
+# Usage: setup.sh "<youtube_url_or_id>"
+#
+# Library location is configurable via the VIDEO_LIBRARY_DIR env var
+# (default: ~/video-deepdives). One markdown file per video lives there.
+set -euo pipefail
+IN="${1:?usage: setup.sh <youtube_url_or_id>}"
+LIB="${VIDEO_LIBRARY_DIR:-$HOME/video-deepdives}"
+
+# Extract 11-char id from common URL shapes, or accept a bare id.
+YTID="$(printf '%s' "$IN" | sed -nE 's#.*(youtu\.be/|v=|/embed/|/shorts/)([A-Za-z0-9_-]{11}).*#\2#p')"
+[ -z "$YTID" ] && [ "${#IN}" -eq 11 ] && YTID="$IN"
+[ -z "$YTID" ] && { echo "Could not parse a YouTube id from: $IN" >&2; exit 1; }
+
+SCRATCH="/tmp/ytnote-$YTID"
+mkdir -p "$SCRATCH"
+
+# Embeddability: oembed returns 200 if embedding allowed, 401 if the owner disabled it.
+CODE="$(curl -s -o /dev/null -w '%{http_code}' \
+  "https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v=$YTID&format=json" || echo "000")"
+if [ "$CODE" = "200" ]; then EMBED="allowed"; else EMBED="BLOCKED (oembed $CODE) — inline player disabled, artifact falls back to YouTube link"; fi
+
+echo "YTID:    $YTID"
+echo "SCRATCH: $SCRATCH"
+echo "EMBED:   $EMBED"
+echo "LIBRARY: $LIB/$YTID.md"

package/bundled-skills/youtube-notetaker/scripts/verify.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Verify a video is correctly served by the standalone server + appears in the index.
+# Usage: verify.sh <YTID> [base_url]
+# Start the server first:  python3 scripts/serve.py --dir <LIBRARY> --port 8000
+set -uo pipefail
+YTID="${1:?usage: verify.sh <YTID> [base_url]}"
+BASE="${2:-http://127.0.0.1:8000}"  # standalone serve.py default port
+COLL="$BASE/api/video-deepdives"
+fail=0
+
+code(){ curl -s -o /dev/null -w '%{http_code}' "$1"; }
+
+echo "1) collection list:"
+C=$(code "$COLL"); echo "   GET $COLL -> $C"; [ "$C" = 200 ] || fail=1
+if curl -s "$COLL" | grep -q "\"$YTID\""; then echo "   ✓ $YTID present in index"; else echo "   ✗ $YTID NOT in index"; fail=1; fi
+
+echo "2) item:"
+C=$(code "$COLL/$YTID"); echo "   GET $COLL/$YTID -> $C"; [ "$C" = 200 ] || fail=1
+
+echo "3) first slide image:"
+C=$(code "$COLL/_media/$YTID-slide-01.jpg"); echo "   GET .../_media/$YTID-slide-01.jpg -> $C"; [ "$C" = 200 ] || fail=1
+
+echo "4) artifact shell:"
+C=$(code "$BASE/"); echo "   GET / -> $C"; [ "$C" = 200 ] || fail=1
+
+if [ "$fail" = 0 ]; then
+  echo "ALL GOOD. Open: $BASE/#/$YTID"
+else
+  echo "SOME CHECKS FAILED — is serve.py running and pointed at the library that contains $YTID?"
+fi
+exit $fail

package/bundled-skills/youtube-notetaker/scripts/vtt_to_transcript.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Convert a YouTube .vtt (manual or auto-captions) into clean [HH:MM:SS] transcript lines.
+
+Usage: vtt_to_transcript.py <input.vtt> <output.txt>
+
+Handles the rolling-duplicate problem in auto-captions: each cue repeats the tail of the
+previous cue, so we keep only newly-added words per cue and emit one line per cue start
+time. Strips inline <00:00:00.000> word-timing tags and HTML tags.
+"""
+import sys, re, html
+
+TS=re.compile(r'(\d{2}):(\d{2}):(\d{2})\.\d{3}\s*-->\s*(\d{2}):(\d{2}):(\d{2})')
+INLINE=re.compile(r'<[^>]+>')
+
+def hhmmss(h,m,s): return f"[{int(h):02d}:{int(m):02d}:{int(s):02d}]"
+
+def clean(text):
+    text=INLINE.sub('',text)
+    text=html.unescape(text)
+    return re.sub(r'\s+',' ',text).strip()
+
+def main():
+    if len(sys.argv)!=3: sys.exit("usage: vtt_to_transcript.py <in.vtt> <out.txt>")
+    raw=open(sys.argv[1],encoding='utf-8',errors='replace').read().splitlines()
+    cues=[]  # (start_label, text)
+    i=0; cur=None
+    while i<len(raw):
+        m=TS.search(raw[i])
+        if m:
+            if cur: cues.append(cur)
+            cur=[hhmmss(*m.groups()[:3]),[]]
+            i+=1
+            while i<len(raw) and not TS.search(raw[i]) and raw[i].strip()!='':
+                if raw[i].strip() and not raw[i].strip().isdigit():
+                    cur[1].append(clean(raw[i]))
+                i+=1
+        else:
+            i+=1
+    if cur: cues.append(cur)
+
+    # De-duplicate rolling captions: keep only the suffix not already seen.
+    out=[]; seen_words=[]
+    for label,parts in cues:
+        text=clean(' '.join(parts))
+        if not text: continue
+        words=text.split()
+        # find longest overlap of seen tail with this cue's head
+        overlap=0; maxk=min(len(words),len(seen_words))
+        for k in range(maxk,0,-1):
+            if seen_words[-k:]==words[:k]: overlap=k; break
+        new=words[overlap:]
+        if new:
+            out.append(f"{label} {' '.join(new)}")
+        seen_words=(seen_words+new)[-40:]  # bounded window
+    with open(sys.argv[2],'w',encoding='utf-8') as f:
+        f.write('\n'.join(out)+'\n')
+    print(f"wrote {len(out)} transcript lines -> {sys.argv[2]}")
+
+if __name__=="__main__": main()

package/bundled-skills/youtube-notetaker/scripts/write_library_item.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Assemble the library markdown file for a video deep-dive.
+
+Usage:
+  write_library_item.py --id <YTID> --title "..." --speaker "..." \
+    --tags a,b,c --slides slides.json --transcript transcript.txt [--created YYYY-MM-DD]
+
+slides.json: a JSON array of slide objects. Each:
+  {
+    "idx": 1,                # sequence/original frame number (display only; sorted by t)
+    "t": 55.7,               # seconds (float ok) — used for video seeking
+    "mmss": "00:55",         # display label
+    "title": "Slide title",  # short headline
+    "note": "1-3 sentences grounded in the transcript at this timestamp.",
+    "img": "/api/video-deepdives/_media/<YTID>-slide-01.jpg"
+  }
+
+Writes  $VIDEO_LIBRARY_DIR/<YTID>.md  (default ~/video-deepdives/<YTID>.md)
+with YAML frontmatter + transcript body. No em dashes or arrows in titles/notes.
+"""
+import argparse, json, os, sys, datetime
+try:
+    import yaml
+except ImportError:
+    sys.exit("pip install pyyaml")
+
+LIB = os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives"))
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument("--id",required=True)
+    ap.add_argument("--title",required=True)
+    ap.add_argument("--speaker",default="")
+    ap.add_argument("--tags",default="")
+    ap.add_argument("--slides",required=True)
+    ap.add_argument("--transcript",required=True)
+    ap.add_argument("--created",default=datetime.date.today().isoformat())
+    a=ap.parse_args()
+
+    slides=json.load(open(a.slides))
+    slides=sorted(slides,key=lambda s:s["t"])
+    for bad in ("—","→"):
+        for s in slides:
+            if bad in (s.get("title") or "")+(s.get("note") or ""):
+                sys.exit(f"Found forbidden char {bad!r} in slide notes/titles; remove it.")
+
+    fm={
+        "id":a.id,
+        "title":a.title,
+        "youtube_id":a.id,
+        "speaker":a.speaker,
+        "source_url":f"https://www.youtube.com/watch?v={a.id}",
+        "slide_count":len(slides),
+        "created":a.created,
+        "tags":[t.strip() for t in a.tags.split(",") if t.strip()],
+        "slides":slides,
+    }
+    body=open(a.transcript,encoding="utf-8").read().strip()
+    os.makedirs(LIB,exist_ok=True)
+    path=os.path.join(LIB,f"{a.id}.md")
+    with open(path,"w",encoding="utf-8") as f:
+        f.write("---\n")
+        yaml.safe_dump(fm,f,sort_keys=False,allow_unicode=True,width=100)
+        f.write("---\n## Transcript\n")
+        f.write(body+"\n")
+    print(f"wrote {path}  ({len(slides)} slides, {len(body.splitlines())} transcript lines)")
+    print("Verify with: scripts/verify.sh "+a.id)
+
+if __name__=="__main__": main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",