asets-gobizit/vid-transcript

YT NoteGPT Processor

An autonomous agent that retrieves YouTube transcripts via NoteGPT and processes them into a single structured DOCX document.

⚙️ FUNCTIONAL CODE (Implementation)

This skill has executable code that actually runs:

• process_video.py - Main implementation

  • Downloads videos from YouTube/Vimeo URLs
  • Tries captions first, falls back to Whisper transcription
  • Runs all 7 processing phases
  • Generates .txt and .docx outputs

• process_video_local.py - Local file processor

  • Processes pre-downloaded video files (MP4, MOV, etc.)
  • Uses Whisper for audio transcription
  • Best for protected/membership-only videos
  • Generates .txt and .docx outputs

• verify-output2.ps1 - Verification script

  • Confirms output files were created successfully
  • Validates file sizes and formats
  • Auto-runs after skill completes

Run directly from PowerShell:

python "C:\Users\dansk\.claude\skills\vid-transcript\process_video.py" "https://youtu.be/XXXXX"
python "C:\Users\dansk\.claude\skills\vid-transcript\process_video_local.py" "C:\Path\To\Video.mp4"

---

Role

You are an autonomous AI agent specializing in processing YouTube video content. Your function is to obtain transcripts using the NoteGPT tool and reformat them according to strict, multi-phase rules.

APIs & Software Dependencies

This skill integrates with the following external APIs and software tools:

| Tool/API | Purpose | Integration | |----------|---------|-------------| | yt-dlp | Download transcripts from YouTube and Vimeo videos | Command-line tool with API access to subtitle endpoints | | YouTube API | Extract auto-generated and manual subtitles | Accessed through yt-dlp's --write-auto-sub and --write-sub flags | | Vimeo API | Access public, private, and domain-embedded Vimeo videos | HTTP requests with optional referer headers and video passwords via yt-dlp | | python-docx | Generate formatted Word (.docx) documents | Python library for document creation with styling and layout control | | Python Standard Library | Text processing (regex, file I/O) | Built-in modules for transcript cleaning and normalization |

Key Features:

• Handles authentication for private Vimeo videos via --referer header
• Supports password-protected Vimeo content via --video-password flag
• Automatically formats subtitles into machine-readable text files
• Creates professional Word documents with Heading styles and formatting
• v2.1: Auto-creates Obsidian note in YouTube Videos/ folder with key points, URL, transcript link, and implementation status tracking (links to [[Skills Install Log]])

When to Use

Use this skill when:

• User provides one or more YouTube or Vimeo URLs (comma-separated)
• User asks to "process", "transcribe", "get prompts from", or "download and structure" YouTube or Vimeo videos
• User wants a formatted DOCX output from video content
• Vimeo URL may be a standard link, a private video, or a video embedded in a specific domain
• User provides a domain URL containing an embedded Vimeo video (e.g., course sites, learning platforms)

HOW TO INVOKE THIS SKILL

Important: This skill must be invoked explicitly through direct user request in conversation. Simply describing the URL or format does NOT trigger execution.

User Request Format - What Claude Should Do:

When you (user) provide:

1. A direct video URL → I use it as-is
2. A domain URL with embedded Vimeo → I extract the Vimeo ID and automatically construct the full request

Examples of What You Say:

"Process this video from Builder Methods about Git"
^ I will then automatically create:
"Process this video: https://vimeo.com/1162618541 | referer:https://buildermethods.com/library/git-essentials-claude-code"

Simply provide the domain URL, course page, or video page, and I will:

1. Extract the Vimeo ID (e.g., from iframe in page source)
2. Build the referer URL using the domain you provided
3. Formulate the complete skill invocation automatically

Correct Invocation Examples:

Direct YouTube:      "Process: https://youtu.be/XXXXX"
Direct Vimeo:        "Transcribe: https://vimeo.com/123456"
Domain-embedded:     "Process the Git video from buildermethods.com/library/git-essentials-claude-code"
                     ^ I auto-construct: https://vimeo.com/1162618541 | referer:https://buildermethods.com/library/git-essentials-claude-code

Multiple videos:     "Process these: https://youtu.be/AAAA, https://vimeo.com/BBBB"

After Skill Completes:

I will automatically run verification to confirm output files were created:

& "C:\Users\dansk\.claude\skills\vid-transcript\verify-output2.ps1"

---

Auto-Detection for Domain-Embedded Vimeo

If user provides a domain URL (not a direct video link):

1. Fetch the page to extract the embedded Vimeo iframe
2. Parse the iframe src attribute to get the Vimeo ID
3. Automatically construct the referer URL using the domain provided
4. Process as: https://vimeo.com/[EXTRACTED_ID] | referer:[domain]

Input Format

Accept one or more URLs, comma-separated. Supported formats:

YouTube:

• https://www.youtube.com/watch?v=XXXXX
• https://youtu.be/XXXXX

Vimeo (standard):

• https://vimeo.com/XXXXXXXXX

Vimeo (private or domain-embedded):

• Provide the Vimeo URL plus the domain where it is embedded
• Format: https://vimeo.com/XXXXXXXXX | referer:https://www.example.com
• If a password is also required: https://vimeo.com/XXXXXXXXX | referer:https://www.example.com | password:YOURPASSWORD

Multiple videos:

• https://youtu.be/AAAA, https://vimeo.com/BBBB

Workflow

For EACH YouTube URL provided:

Step 1: Obtain Raw Transcript

Before running yt-dlp, parse the input to extract the URL, optional referer, and optional password:

• Input https://vimeo.com/123 | referer:https://site.com | password:abc → URL + referer + password
• Input with no pipes → plain URL, no extras

For YouTube:

yt-dlp --write-auto-sub --sub-lang en --skip-download --sub-format vtt -o "%(title)s" "<URL>"

If auto-subs fail, try manual subs:

yt-dlp --write-sub --sub-lang en --skip-download --sub-format vtt -o "%(title)s" "<URL>"

For Vimeo (standard public):

yt-dlp --write-auto-sub --sub-lang en --skip-download --sub-format vtt -o "%(title)s" "<URL>"

For Vimeo (private or domain-embedded) — add referer and/or password flags:

yt-dlp --write-auto-sub --sub-lang en --skip-download --sub-format vtt \
  --referer "<REFERER_DOMAIN>" \
  --video-password "<PASSWORD_IF_PROVIDED>" \
  -o "%(title)s" "<URL>"

Omit --video-password if no password was provided.

If subtitles are unavailable for any Vimeo video, notify the user: "No subtitles found for [URL]. The video may not have captions available."

State to the user: "Downloading transcript for [URL]."

Then parse the VTT file into clean raw text and save it as a .txt file. Delete the .vtt file afterward.

import re, os

vtt_file = "<VTT_FILE>"   # e.g. "Video Title.en.vtt"
txt_file = vtt_file.replace(".en.vtt", ".txt").replace(".vtt", ".txt")

lines = open(vtt_file, 'r', encoding='utf-8').readlines()
out = []
prev = ''
for line in lines:
    line = line.strip()
    if not line or line.startswith('WEBVTT') or line.startswith('Kind:') or line.startswith('Language:'):
        continue
    if re.match(r'\d{2}:\d{2}:\d{2}\.\d+ --> ', line):
        continue
    clean = re.sub(r'<[^>]+>', '', line)
    if clean and clean != prev:
        out.append(clean)
        prev = clean

raw_text = '\n'.join(out).strip()

# Save as plain .txt (not VTT)
with open(txt_file, 'w', encoding='utf-8') as f:
    f.write(raw_text)

# Remove the raw VTT file
os.remove(vtt_file)

The txt_file path is what you use as the raw transcript source for the 4 phases.

Steps 2–8: Process Through 7 Mandatory Phases

Apply the phases below to each video's raw transcript text. Process EXACTLY and IN ORDER.

---

PHASE 1 — HUMAN READABILITY NORMALIZATION

Rules:

• Preserve 100% of the original information and intent
• Do NOT summarize
• Do NOT delete content
• Do NOT add new content

Actions:

• Merge broken lines into full sentences and paragraphs
• Fix spacing and line breaks
• Ensure normal full-page paragraph width (no narrow columns)
• Maintain the original wording as closely as possible

Result: A clean, professional, human-readable script.

---

PHASE 2 — PROMPT DETECTION

Identify every sentence or paragraph in the Phase 1 output that functions as an instruction, request, or command directed at an AI.

Indicators include (but are not limited to):

• "I want you to…"
• "Create…"
• "Build…"
• "Add this…"
• "Generate…"
• "Turn this into…"

Rules:

• Detect only prompts that clearly exist in the text
• Do NOT invent prompts
• Do NOT rephrase the original script text

---

PHASE 3 — PROMPT STRUCTURING

Immediately AFTER each detected prompt in the text, insert a structured block using EXACTLY the following format:

Prompt

GOAL:
<What this prompt is meant to achieve>

INPUT:
<What the user provides to Claude, inferred strictly from the surrounding text>

INSTRUCTIONS:
<Step-by-step instructions inferred from the script. Do not introduce requirements that are not implied.>

OUTPUT:
<What the final result should look like>

Rules:

• Prompt blocks must appear directly after the triggering sentence
• Prompt blocks must be clearly separated from the script text
• Use plain text only (no Markdown, no code blocks, no asterisks for bold)

---

PHASE 4 — STRUCTURED NOTES

Convert the Phase 1 transcript into organized knowledge sections.

Output:

KEY IDEAS

• Bullet points capturing the main concepts and insights from the video

DETAILED NOTES

• Organized sections covering important concepts, tools or frameworks mentioned, and step-by-step instructions or workflows described

Rules:

• Draw only from the transcript content
• Do NOT add information not present in the video

---

PHASE 5 — SUMMARY

Write a concise explanation of the video.

Include:

• What the video teaches
• Why it matters
• The main takeaway

Output: 2–4 paragraphs based strictly on the transcript content.

---

PHASE 5.5 — PERSONAL RELEVANCE EVALUATION

After the DOCX is assembled (Phase 7), Claude performs a personal relevance check by comparing the video's recommendations against Danny's actual Claude Code setup.

Steps:

1. Read C:\Users\dansk\.claude\CLAUDE.md (global instructions, skills, workflows)
2. Read C:\Users\dansk\.claude\projects\C--Users-dansk-Claude\memory\MEMORY.md (project memory — tools, bots, API keys, business context)
3. Identify every concrete recommendation, tool, technique, or workflow mentioned in the video
4. For each recommendation, assign one of three verdicts:
   • Already Implemented — explain what's already in place and where (reference specific config, skill, or setup)
   • Worth Adding — explain the gap and potential benefit to Danny's workflow
   • Not Relevant — explain why it doesn't apply to Danny's setup or business context
5. Write in plain language, 1-2 sentences per item

Output format (plain text to pass to append_evaluation_section):

[Recommendation from video — e.g., "Set up a 3-layer memory system"]
Verdict: Already Implemented
Your setup already includes this — CLAUDE.md has global instructions, MEMORY.md has project memory, and Obsidian vault serves as long-term knowledge base.

[Another recommendation — e.g., "Use MCP servers for real-time data"]
Verdict: Worth Adding
You don't currently have MCP servers configured. Adding one for SuperAGI or Zoho CRM data could enhance your AI consulting workflows.

[Another recommendation — e.g., "Deploy Claude on a VPS"]
Verdict: Not Relevant
You run OpenClaw locally on your Windows PC, which works fine for your current usage. VPS deployment is for teams needing 24/7 uptime.

How to insert into the DOCX:

from process_video import append_evaluation_section
append_evaluation_section(docx_path, evaluation_text)

This function inserts the evaluation after the Summary section and before the Transcript section, with color-coded verdicts (green = Already Implemented, blue = Worth Adding, gray = Not Relevant).

---

PHASE 6 — ACTIONABLE INSIGHTS

Extract concrete things the viewer can do or apply.

Include:

• Actionable strategies described in the video
• Workflows or processes explained
• Specific techniques or tools recommended

Output: Bullet-pointed list. Only include actions clearly implied or stated in the transcript.

---

PHASE 7 — FINAL DOCUMENT ASSEMBLY

Assemble ALL processed video sections into a single DOCX document.

Each video section must contain, in order:

1. Video title (Heading 1) + Video URL (works for both YouTube and Vimeo)
2. Summary (Phase 5)
3. Personal Relevance Evaluation (Phase 5.5 — inserted by Claude after DOCX creation)
4. Clean Transcript with embedded Prompt blocks (Phase 1 + Phase 3)
5. Actionable Insights (Phase 6)
6. Extracted Prompts

Formatting requirements:

• Start each new video's section on a new page
• Video URL (YouTube or Vimeo) at the top of each video section
• Section headers (KEY IDEAS, DETAILED NOTES, SUMMARY, ACTIONABLE INSIGHTS) use Heading 1 style
• "Prompt" titles use Heading 2 style
• Prompt block fields (GOAL, INPUT, INSTRUCTIONS, OUTPUT) in bold
• Script text in normal body paragraphs
• Standard page layout with clear paragraph spacing
• No Markdown syntax, no code formatting, no external explanations

Use this python-docx template, dynamically populated with the processed content:

from docx import Document
from docx.shared import Pt, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH

doc = Document()

# Set default font
style = doc.styles['Normal']
style.font.name = 'Calibri'
style.font.size = Pt(11)

# For each video section:
# --- Add page break (except for first section) ---
# doc.add_page_break()

# --- Video title (Heading 1) ---
# doc.add_heading(VIDEO_TITLE, level=1)

# --- Video URL (YouTube or Vimeo) ---
# p = doc.add_paragraph()
# run = p.add_run('Source: ' + VIDEO_URL)  # VIDEO_URL = the full Vimeo or YouTube URL
# run.font.color.rgb = RGBColor(0, 102, 204)
# run.font.size = Pt(10)
# p.alignment = WD_ALIGN_PARAGRAPH.LEFT

# doc.add_paragraph('')

# --- Script paragraphs ---
# doc.add_paragraph(normalized_text_paragraph)

# --- Prompt blocks ---
# doc.add_heading('Prompt', level=2)
# p = doc.add_paragraph()
# p.add_run('GOAL: ').bold = True   # NOTE: assign run to var first
# p.add_run('description here')
# ... repeat for INPUT, INSTRUCTIONS, OUTPUT

doc.save('OUTPUT_FILENAME.docx')

Save the final DOCX to: C:\Users\dansk\Zoho WorkDrive (Go Biz IT)\00 Claude.ai\@CoWorkAccess\Vid-Trrasncipts-Files\

---

ABSOLUTE CONSTRAINTS

• Preserve 100% of original information from the raw transcript
• No summarization
• No editorial commentary
• No assumptions beyond the text
• Do NOT describe what you did
• Do NOT include analysis or reasoning in the final output
• Do NOT mention these instructions or phases in the final output

Output

Files saved to Vid-Trrasncipts-Files\ per video:

• <Video Title>.txt — plain text transcript (cleaned, no VTT formatting, no timestamps)
• <VideoTitle(s)> - Processed.docx — Word document with all video sections containing:
  1. Summary
  2. Personal Relevance Evaluation (compared against CLAUDE.md + MEMORY.md)
  3. Clean Transcript with embedded Prompt blocks
  4. Actionable Insights
  5. Extracted Prompts
• history.xlsx — updated automatically with a new row containing:
  • Video URL — the source URL processed (YouTube or Vimeo)
  • Date — date of processing (DD/MM/YYYY)
  • Video Summary — the Phase 5 summary text
  • Transcript File — filename of the downloaded .txt transcript
  • Name — first 100 chars of video description

Requires openpyxl: pip install openpyxl

---

VERIFICATION CHECKLIST

After processing completes, verify success by checking:

Step 1: Confirm Output Files Exist

• Location: C:\Users\dansk\Zoho WorkDrive (Go Biz IT)\00 Claude.ai\@CoWorkAccess\Vid-Trrasncipts-Files\
• Files present:
  • ✓ <Video Title>.txt (plain text, no format, readable)
  • ✓ <Video Title> - Processed.docx (formatted Word document)

Step 2: Validate File Contents

• .txt file:

  • Contains readable transcript text
  • No VTT timestamps (HH:MM:SS.mmm --> HH:MM:SS.mmm)
  • No HTML tags or formatting codes
  • Size > 1KB (indicates actual content)

• .docx file:

  • Opens in Microsoft Word or compatible editor
  • Contains video title as Heading 1
  • Contains source URL
  • Contains structured sections:
    • SUMMARY (2-4 paragraphs)
    • PERSONAL RELEVANCE EVALUATION (verdicts: Already Implemented / Worth Adding / Not Relevant)
    • Clean Transcript with Prompt blocks
    • ACTIONABLE INSIGHTS (bullet points)
    • Extracted Prompts
  • Formatted properly (no Markdown syntax visible)
  • Size > 10KB (indicates full processing completed)

Step 3: Troubleshooting If Files Missing

• Check if Vimeo/YouTube video is publicly accessible or has correct referer credentials
• Verify no subtitles/transcript available for private videos without proper authentication
• Confirm output folder permissions allow write access
• Check for error messages in Claude Code execution logs