@clubnet/seedclub 0.2.33 → 0.2.35

package/assets/extensions/seedclub/commands/transcript-export-helpers.js

@@ -0,0 +1,354 @@
+function normalizeWhitespace(value) {
+	return value.replace(/[\u2018\u2019]/g, "'").replace(/\s+/g, " ").trim();
+}
+
+const NON_PERSON_QUERIES = new Set([
+	"both",
+	"all",
+	"everyone",
+	"everybody",
+	"anyone",
+	"anybody",
+	"each",
+	"each of these",
+	"all of these",
+	"these",
+	"those",
+	"this",
+	"them",
+	"the above",
+	"above",
+	"interviews",
+	"calls",
+	"meetings",
+	"conversations",
+	"episodes",
+]);
+
+const NON_PERSON_PREFIXES = new Set([
+	"i",
+	"we",
+	"download",
+	"get",
+	"grab",
+	"pull",
+	"save",
+	"export",
+	"need",
+	"want",
+	"send",
+	"give",
+	"retrieve",
+	"latest",
+	"last",
+	"most",
+	"recent",
+	"the",
+]);
+
+const NON_PERSON_TOKENS = new Set([
+	"i",
+	"we",
+	"me",
+	"us",
+	"need",
+	"want",
+	"download",
+	"export",
+	"get",
+	"last",
+	"latest",
+	"recent",
+	"stream",
+	"show",
+	"11am",
+]);
+
+function trimQuotes(value) {
+	return value.replace(/^['\"]|['\"]$/g, "");
+}
+
+function normalizePersonQuery(raw) {
+	if (!raw) return undefined;
+	const cleaned = normalizeWhitespace(raw)
+		.replace(/\b(?:interviews?|calls?|meetings?|conversations?|episodes?|transcripts?|vtts?|stream|show)\b/gi, "")
+		.replace(/\b(?:each|all)\s+of\s+(?:these|those|them)\b/gi, "")
+		.replace(/\b(?:on|at|in|from)\b\s*$/i, "")
+		.trim();
+	if (!cleaned) return undefined;
+
+	const lower = cleaned.toLowerCase();
+	if (NON_PERSON_QUERIES.has(lower)) return undefined;
+	if (
+		/\b(today(?:'s|s)?|yesterday(?:'s|s)?|tomorrow(?:'s|s)?|tonight|morning|afternoon|evening|monday|mon|tuesday|tues|tue|toesday|wednesday|wed|thursday|thurs|thu|friday|fri|saturday|sat|sunday|sun|latest|recent|last)\b/.test(
+			lower,
+		)
+	) {
+		return undefined;
+	}
+	if (/^\d{1,2}(?::\d{2})?\s*(?:am|pm)$/.test(lower)) return undefined;
+	if (/^(?:these|those|this|them|each|the\s+above|above)$/.test(lower)) return undefined;
+
+	const parts = lower.split(/\s+/).filter(Boolean);
+	if (!parts.length) return undefined;
+
+	const firstWord = parts[0];
+	if (NON_PERSON_PREFIXES.has(firstWord)) return undefined;
+	if (parts.some((part) => NON_PERSON_TOKENS.has(part))) return undefined;
+
+	return cleaned;
+}
+
+function formatLocalDate(date) {
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+}
+
+function addLocalDays(date, days) {
+	const next = new Date(date);
+	next.setDate(next.getDate() + days);
+	return next;
+}
+
+function parseRelativeDateHint(text) {
+	const lower = normalizeWhitespace(text).toLowerCase();
+	const today = new Date();
+
+	if (/\b(today(?:'s|s)?|tonight)\b/.test(lower)) return formatLocalDate(today);
+	if (/\byesterday(?:'s|s)?\b/.test(lower)) return formatLocalDate(addLocalDays(today, -1));
+	if (/\btomorrow(?:'s|s)?\b/.test(lower)) return formatLocalDate(addLocalDays(today, 1));
+
+	const weekdayMatch = lower.match(
+		/\b(?:(last|next)\s+)?(monday|mon|tuesday|tues|tue|toesday|wednesday|wed|thursday|thurs|thu|friday|fri|saturday|sat|sunday|sun)(?:'s|s)?\b/,
+	);
+	if (!weekdayMatch) return undefined;
+
+	const weekdayByName = {
+		sunday: 0,
+		sun: 0,
+		monday: 1,
+		mon: 1,
+		tuesday: 2,
+		tues: 2,
+		tue: 2,
+		toesday: 2,
+		wednesday: 3,
+		wed: 3,
+		thursday: 4,
+		thurs: 4,
+		thu: 4,
+		friday: 5,
+		fri: 5,
+		saturday: 6,
+		sat: 6,
+	};
+	const modifier = weekdayMatch[1];
+	const targetDay = weekdayByName[weekdayMatch[2]];
+	const currentDay = today.getDay();
+	let offset = targetDay - currentDay;
+
+	if (modifier === "next") {
+		offset = offset <= 0 ? offset + 7 : offset;
+	} else if (modifier === "last") {
+		offset = offset >= 0 ? offset - 7 : offset;
+	} else if (offset > 0) {
+		offset -= 7;
+	}
+
+	return formatLocalDate(addLocalDays(today, offset));
+}
+
+function parseDateHint(text) {
+	const iso = text.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+	if (iso?.[1]) return iso[1];
+
+	const relative = parseRelativeDateHint(text);
+	if (relative) return relative;
+
+	const monthDay = text.match(/\b(?:on\s+)?(january|february|march|april|may|june|july|august|september|october|november|december)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+(\d{4}))?\b/i);
+	if (!monthDay) return undefined;
+
+	const monthNames = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
+	const monthIndex = monthNames.indexOf(monthDay[1].toLowerCase());
+	if (monthIndex < 0) return undefined;
+
+	const day = Number.parseInt(monthDay[2], 10);
+	if (!Number.isFinite(day) || day < 1 || day > 31) return undefined;
+
+	const year = monthDay[3] ? Number.parseInt(monthDay[3], 10) : new Date().getFullYear();
+	const date = new Date(Date.UTC(year, monthIndex, day));
+	if (Number.isNaN(date.getTime())) return undefined;
+	return date.toISOString().slice(0, 10);
+}
+
+function parseIntent(input) {
+	const text = normalizeWhitespace(input);
+	const intent = {};
+
+	const betweenPair = text.match(/\bbetween\s+([\w'. -]{2,80}?)\s*(?:and|&)\s*([\w'. -]{2,80}?)(?=\s+(?:from|on|in|at|for|transcripts?|vtts?|interviews?|calls?|meetings?|date|to)\b|[?.!,]|$)/i);
+	if (betweenPair?.[1] && betweenPair?.[2]) {
+		const first = normalizePersonQuery(betweenPair[1]);
+		const second = normalizePersonQuery(betweenPair[2]);
+		const people = [first, second].filter(Boolean);
+		if (people.length) intent.people = Array.from(new Set(people));
+	}
+
+	const personWith = text.match(/\bwith\s+([\w'. -]{2,80}?)(?=\s+(?:from|on|in|at|for|transcripts?|vtts?|interviews?|calls?|meetings?|date|to)\b|$)/i);
+	if (personWith?.[1]) intent.person = normalizePersonQuery(personWith[1]);
+
+	if (!intent.person) {
+		const personFor = text.match(/\bfor\s+([\w'. -]{2,80}?)(?=\s+(?:from|on|in|at|transcripts?|vtts?|interviews?|calls?|meetings?|date|to)\b|$)/i);
+		if (personFor?.[1]) intent.person = normalizePersonQuery(personFor[1]);
+	}
+
+	if (!intent.person) {
+		const verbBeforeTranscript = text.match(
+			/\b(?:download|get|export|save|pull|grab|retrieve|fetch|send|give)\s+([a-z][\w'.-]*(?:\s+[a-z][\w'.-]*){0,3})\s+transcripts?\b/i,
+		);
+		if (verbBeforeTranscript?.[1]) {
+			intent.person = normalizePersonQuery(verbBeforeTranscript[1]);
+		}
+	}
+
+	if (!intent.person) {
+		const beforeTranscript = text.match(/\b([a-z][\w'.-]*(?:\s+[a-z][\w'.-]*){0,3})\s+transcripts?\b/i);
+		if (beforeTranscript?.[1]) {
+			const candidate = normalizePersonQuery(beforeTranscript[1]);
+			if (candidate && !/\b(?:need|want|download|get|last|latest)\b/i.test(candidate)) {
+				intent.person = candidate;
+			}
+		}
+	}
+
+	if ((!intent.people || !intent.people.length) && intent.person) {
+		intent.people = [intent.person];
+	}
+
+	const latestN = text.match(/\b(?:last|latest|most recent)\s+(\d{1,2})\b/i);
+	if (latestN?.[1]) {
+		intent.latestCount = Math.max(1, Math.min(20, Number.parseInt(latestN[1], 10)));
+	} else if (/\b(?:last|latest|most recent)\b/i.test(text)) {
+		intent.latestCount = 1;
+	} else if (/\brecent\b/i.test(text)) {
+		intent.latestCount = 5;
+	}
+
+	intent.date = parseDateHint(text);
+	if ((intent.people?.length ?? 0) > 1 && /\b(?:both|between|across|and|&)\b/i.test(text)) {
+		intent.date = undefined;
+	}
+
+	const explicitTimeMatch = text.match(/\b(?:at|time)\s+(\d{1,2}(?::\d{2})?\s*(?:am|pm)|(?:[01]?\d|2[0-3]):[0-5]\d)\b/i);
+	const bareTimeMatch = text.match(/\b((?:[1-9]|1[0-2])(?::\d{2})?\s*(?:am|pm)|(?:[01]?\d|2[0-3]):[0-5]\d)\b/i);
+	const timeMatch = explicitTimeMatch ?? bareTimeMatch;
+	if (timeMatch?.[1]) {
+		const normalizedTime = timeMatch[1].replace(/\s+/g, "").toLowerCase();
+		if (explicitTimeMatch || normalizedTime !== "11am") intent.time = normalizedTime;
+	}
+
+	const outMatch = text.match(/\b(?:to|into|in)\s+(~\/\S+|\/\S+)/i);
+	if (outMatch?.[1]) intent.outDir = trimQuotes(outMatch[1]);
+
+	return intent;
+}
+
+function parseTimeFilter(input) {
+	if (!input) return null;
+	const value = input.trim().toLowerCase();
+	const twentyFourHour = value.match(/^([01]?\d|2[0-3]):([0-5]\d)$/);
+	if (twentyFourHour) {
+		return {
+			hour: Number.parseInt(twentyFourHour[1], 10),
+			minute: Number.parseInt(twentyFourHour[2], 10),
+		};
+	}
+
+	const match = value.match(/^(\d{1,2})(?::(\d{2}))?(am|pm)$/);
+	if (!match) return null;
+	let hour = Number.parseInt(match[1], 10);
+	const minute = match[2] ? Number.parseInt(match[2], 10) : undefined;
+	const period = match[3];
+	if (hour < 1 || hour > 12) return null;
+	if (minute !== undefined && (minute < 0 || minute > 59)) return null;
+	if (period === "am") {
+		hour = hour === 12 ? 0 : hour;
+	} else {
+		hour = hour === 12 ? 12 : hour + 12;
+	}
+	return { hour, minute };
+}
+
+function normalizeFuzzyText(value) {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9\s]/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function exactNormalizedTextMatch(query, target) {
+	const q = normalizeFuzzyText(query);
+	const t = normalizeFuzzyText(target);
+	if (!q || !t) return false;
+	if (q === t) return true;
+	return new RegExp(`(^| )${q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}( |$)`).test(t);
+}
+
+function normalizeTranscriptText(value) {
+	return value.replace(/\r\n/g, "\n").trim();
+}
+
+function isLikelyVtt(value) {
+	const text = value.trim();
+	if (!text) return false;
+	return /^WEBVTT\b/i.test(text) || /\d{2}:\d{2}:\d{2}[\.,]\d{3}\s+-->\s+\d{2}:\d{2}:\d{2}[\.,]\d{3}/.test(text);
+}
+
+function toTimestamp(totalSeconds) {
+	const ms = Math.max(0, Math.floor(totalSeconds * 1000));
+	const h = Math.floor(ms / 3600000);
+	const m = Math.floor((ms % 3600000) / 60000);
+	const s = Math.floor((ms % 60000) / 1000);
+	const milli = ms % 1000;
+	return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}.${String(milli).padStart(3, "0")}`;
+}
+
+function textToSyntheticVtt(text) {
+	const normalized = normalizeTranscriptText(text);
+	if (!normalized) return null;
+
+	const sections = normalized
+		.split(/\n\s*\n+/)
+		.map((value) => value.trim())
+		.filter(Boolean)
+		.slice(0, 500);
+	if (!sections.length) return null;
+
+	let cursor = 0;
+	const cues = [];
+	for (const section of sections) {
+		const charCount = section.length;
+		const duration = Math.max(2, Math.min(10, Math.ceil(charCount / 28)));
+		const start = toTimestamp(cursor);
+		const end = toTimestamp(cursor + duration);
+		cues.push(`${start} --> ${end}\n${section}`);
+		cursor += duration;
+	}
+
+	return `WEBVTT\n\n${cues.join("\n\n")}`;
+}
+
+export {
+	exactNormalizedTextMatch,
+	isLikelyVtt,
+	normalizeFuzzyText,
+	normalizePersonQuery,
+	normalizeWhitespace,
+	parseDateHint,
+	parseIntent,
+	parseRelativeDateHint,
+	parseTimeFilter,
+	textToSyntheticVtt,
+};