pi-yt-summarizer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 x0d7x
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# pi-yt-summarizer
+
+A Pi coding agent extension that fetches YouTube video info, descriptions, and transcripts for summarization. Also generates video ideas on any topic.
+
+## Features
+
+- **`summarize_youtube` tool** — LLM can automatically fetch video info when you share a YouTube link
+- **`/yt <url>`** — Command to pre-fill editor with a summarization prompt
+- **`/yt-ideas <topic>`** — Generate 5–10 YouTube video ideas on any topic
+
+## Requirements
+
+- [yt-dlp](https://github.com/yt-dlp/yt-dlp) installed and in PATH
+
+## Install
+
+```bash
+pi install npm:pi-yt-summarizer
+# or
+pi install git:github.com/x0d7x/pi-yt-summarizer
+```
+
+## Usage
+
+```
+# Ask the LLM directly:
+Summarize https://www.youtube.com/watch?v=oL9neMViXAI
+
+# Or use commands:
+/yt https://www.youtube.com/watch?v=oL9neMViXAI
+/yt-ideas linux distro review
+```
+
+## License
+
+MIT

package/extensions/youtube-summarizer.ts

@@ -0,0 +1,233 @@
+/**
+ * YouTube Video Summarizer Extension
+ *
+ * Fetches video info and transcript from a YouTube URL and returns it
+ * for summarization. Uses yt-dlp under the hood.
+ *
+ * Usage:
+ *   - Ask the LLM: "Summarize https://youtube.com/watch?v=..."
+ *   - Or run /yt <url>
+ *   - Or run /yt-ideas <topic>
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { readFile, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+function formatDuration(ms: number): string {
+	const totalSec = Math.floor(ms / 1000);
+	const h = Math.floor(totalSec / 3600);
+	const m = Math.floor((totalSec % 3600) / 60);
+	const s = totalSec % 60;
+	if (h > 0) return `${h}h${m}m${s}s`;
+	if (m > 0) return `${m}m${s}s`;
+	return `${s}s`;
+}
+
+interface TranscriptEvent {
+	tStartMs?: number;
+	dDurationMs?: number;
+	segs?: Array<{ utf8?: string }>;
+}
+
+/** Parse yt-dlp json3 transcript and return clean text + structured segments */
+async function parseTranscript(jsonPath: string): Promise<{
+	fullText: string;
+	segments: Array<{ time: string; text: string }>;
+}> {
+	const raw = await readFile(jsonPath, "utf-8");
+	const data = JSON.parse(raw);
+	const events: TranscriptEvent[] = data.events ?? [];
+
+	const segments: Array<{ time: string; text: string }> = [];
+	const fullLines: string[] = [];
+
+	for (const ev of events) {
+		const segs = ev.segs ?? [];
+		const text = segs.map((s) => s.utf8 ?? "").join("").trim();
+		if (!text) continue;
+
+		const timeStr = ev.tStartMs !== undefined ? formatDuration(ev.tStartMs) : "";
+		segments.push({ time: timeStr, text });
+		fullLines.push(text);
+	}
+
+	return {
+		fullText: fullLines.join(" "),
+		segments,
+	};
+}
+
+function extractYouTubeId(url: string): string | null {
+	const patterns = [
+		/(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/shorts\/)([a-zA-Z0-9_-]{11})/,
+		/^([a-zA-Z0-9_-]{11})$/,
+	];
+	for (const p of patterns) {
+		const m = url.match(p);
+		if (m) return m[1];
+	}
+	return null;
+}
+
+export default function (pi: ExtensionAPI) {
+	// ── Custom tool ──────────────────────────────────────────────
+	pi.registerTool({
+		name: "summarize_youtube",
+		label: "YouTube Summarizer",
+		description: "Fetch video info, description, and transcript from a YouTube URL. Returns structured data for summarization.",
+		promptSnippet: "Summarize or fetch information from YouTube videos",
+		promptGuidelines: [
+			"Use summarize_youtube when the user shares a YouTube link and asks you to summarize, explain, or extract information from it.",
+		],
+		parameters: Type.Object({
+			url: Type.String({ description: "YouTube video URL (e.g. https://youtube.com/watch?v=...)" }),
+		}),
+
+		async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+			const url = params.url.trim();
+			const videoId = extractYouTubeId(url);
+			if (!videoId) {
+				return {
+					content: [{ type: "text", text: `Invalid YouTube URL: ${url}` }],
+					details: { error: "Could not extract video ID" },
+					isError: true,
+				};
+			}
+
+			let infoResult: { stdout: string; stderr: string; code: number; killed?: boolean };
+			let transcriptPath = "";
+
+			try {
+				// 1. Get title & description
+				infoResult = await pi.exec("yt-dlp", [
+					"--print", "title",
+					"--print", "description",
+					"-s", url,
+				], { signal });
+
+				const lines = infoResult.stdout.trim().split("\n");
+				const title = lines[0] ?? "Unknown";
+				const description = lines.slice(1).join("\n").trim();
+
+				// 2. Download auto-generated transcript (json3 format)
+				const ts = Date.now();
+				transcriptPath = `/tmp/pi_yt_${ts}`;
+				await pi.exec("yt-dlp", [
+					"--write-auto-subs", "--sub-langs", "en",
+					"--skip-download", "--sub-format", "json3",
+					"-o", transcriptPath, url,
+				], { signal });
+
+				// 3. Parse transcript
+				const jsonPath = `${transcriptPath}.en.json3`;
+				let transcriptText = "(no transcript available)";
+				let segments: Array<{ time: string; text: string }> = [];
+
+				if (existsSync(jsonPath)) {
+					const parsed = await parseTranscript(jsonPath);
+					transcriptText = parsed.fullText;
+					segments = parsed.segments;
+				}
+
+				// If English subs not found, try auto-detected language
+				if (!transcriptText || transcriptText === "(no transcript available)") {
+					const autoJsonPath = `${transcriptPath}.en-orig.json3`;
+					if (existsSync(autoJsonPath)) {
+						const parsed = await parseTranscript(autoJsonPath);
+						transcriptText = parsed.fullText;
+						segments = parsed.segments;
+					}
+				}
+
+				// 4. Build structured output
+				const resultParts: string[] = [
+					`## ${title}`,
+					``,
+					`**URL:** ${url}`,
+					`**Duration:** ${segments.length > 0 ? segments[segments.length - 1]?.time ?? "?" : "?"}`,
+					``,
+					`### Description`,
+					description || "(no description)",
+					``,
+				];
+
+				if (transcriptText && transcriptText !== "(no transcript available)") {
+					// Truncate transcript to avoid blowing up context
+					const maxTranscriptLen = 15000;
+					const truncated = transcriptText.length > maxTranscriptLen
+						? transcriptText.slice(0, maxTranscriptLen) + `\n\n[...transcript truncated at ${maxTranscriptLen} chars, full length: ${transcriptText.length} chars]`
+						: transcriptText;
+
+					resultParts.push(`### Transcript (${transcriptText.length} chars)`);
+					resultParts.push(truncated);
+				} else {
+					resultParts.push("*(No transcript available for this video)*");
+				}
+
+				return {
+					content: [{ type: "text", text: resultParts.join("\n") }],
+					details: {
+						title,
+						description: description.slice(0, 2000),
+						transcriptLength: transcriptText.length,
+						segmentCount: segments.length,
+					},
+				};
+			} catch (err: any) {
+				const msg = err?.message ?? String(err);
+				return {
+					content: [{ type: "text", text: `Error fetching video: ${msg}` }],
+					details: { error: msg },
+					isError: true,
+				};
+			} finally {
+				// Cleanup temp files
+				if (transcriptPath) {
+					try { await unlink(`${transcriptPath}.en.json3`); } catch {}
+					try { await unlink(`${transcriptPath}.en.vtt`); } catch {}
+					try { await unlink(`${transcriptPath}.en-orig.json3`); } catch {}
+				}
+			}
+		},
+	});
+
+	// ── /yt command for direct use ──────────────────────────────
+	pi.registerCommand("yt", {
+		description: "Summarize a YouTube video (usage: /yt <url>)",
+		handler: async (args, ctx) => {
+			const url = args.trim();
+			if (!url) {
+				ctx.ui.notify("Usage: /yt <youtube-url>", "warning");
+				return;
+			}
+
+			ctx.ui.setEditorText(`Summarize this YouTube video: ${url}`);
+			ctx.ui.notify("Press Enter to summarize", "info");
+		},
+	});
+
+	// ── /yt-ideas command ────────────────────────────────────────
+	pi.registerCommand("yt-ideas", {
+		description: "Generate YouTube video ideas on a topic (usage: /yt-ideas <topic>)",
+		handler: async (args, ctx) => {
+			const topic = args.trim();
+			if (!topic) {
+				ctx.ui.notify("Usage: /yt-ideas <topic>", "warning");
+				return;
+			}
+
+			ctx.ui.setEditorText(
+				`Generate 5-10 YouTube video ideas about "${topic}". ` +
+				`For each idea include:\n` +
+				`- Catchy title\n` +
+				`- Target audience\n` +
+				`- Key points to cover\n` +
+				`- Estimated video length\n` +
+				`- Why it would perform well`
+			);
+			ctx.ui.notify("Press Enter to generate video ideas", "info");
+		},
+	});
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "pi-yt-summarizer",
+  "version": "0.1.0",
+  "description": "YouTube summarizer extension for Pi — fetch video info, transcript, and generate video ideas",
+  "keywords": ["pi-package", "pi-extension", "youtube", "summarizer", "transcript"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/x0d7x/pi-yt-summarizer.git"
+  },
+  "pi": {
+    "extensions": ["./extensions/youtube-summarizer.ts"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}