@clubnet/seedclub 0.2.32 → 0.2.34

package/assets/extensions/seedclub/auth.ts

@@ -20,8 +20,6 @@ const DEFAULT_AUTH_BASE = "https://auth.seedclub.com";
 const LOCAL_API_BASE = "http://localhost:3001";
 const LOCAL_AUTH_BASE = "http://localhost:3000";
 
-export type SeedclubEnvironmentMode = "local" | "prod" | "custom";
-
 export interface StoredToken {
 	token: string;
 	email: string;
@@ -34,8 +32,6 @@ export interface StoredToken {
 export interface StoredBases {
 	apiBase: string;
 	authBase: string;
-	mode: SeedclubEnvironmentMode;
-	updatedAt: string;
 }
 
 let _cachedApiBase: string | null = null;
@@ -50,6 +46,23 @@ function shouldPreferLocalBases(): boolean {
 	);
 }
 
+function normalizeStoredBases(value: unknown): StoredBases | null {
+	if (!value || typeof value !== "object") {
+		return null;
+	}
+
+	const stored = value as Partial<StoredBases>;
+
+	if (typeof stored.apiBase !== "string" || typeof stored.authBase !== "string") {
+		return null;
+	}
+
+	return {
+		apiBase: stored.apiBase,
+		authBase: stored.authBase,
+	};
+}
+
 function tryReadStoredBasesSync(): StoredBases | null {
 	if (_cachedBases !== undefined) {
 		return _cachedBases;
@@ -57,13 +70,8 @@ function tryReadStoredBasesSync(): StoredBases | null {
 
 	try {
 		const content = readFileSync(BASES_FILE, "utf-8");
-		const stored = JSON.parse(content) as StoredBases;
-		if (
-			!stored ||
-			typeof stored.apiBase !== "string" ||
-			typeof stored.authBase !== "string" ||
-			typeof stored.mode !== "string"
-		) {
+		const stored = normalizeStoredBases(JSON.parse(content));
+		if (!stored) {
 			_cachedBases = null;
 			return null;
 		}
@@ -158,13 +166,8 @@ export async function getStoredToken(): Promise<StoredToken | null> {
 export async function getStoredBases(): Promise<StoredBases | null> {
 	try {
 		const content = await readFile(BASES_FILE, "utf-8");
-		const stored = JSON.parse(content) as StoredBases;
-		if (
-			!stored ||
-			typeof stored.apiBase !== "string" ||
-			typeof stored.authBase !== "string" ||
-			typeof stored.mode !== "string"
-		) {
+		const stored = normalizeStoredBases(JSON.parse(content));
+		if (!stored) {
 			return null;
 		}
 		_cachedBases = stored;
@@ -183,13 +186,10 @@ export async function getToken(): Promise<string | null> {
 export async function storeBases(
 	apiBase: string,
 	authBase: string,
-	mode: SeedclubEnvironmentMode = "custom",
 ): Promise<void> {
 	const stored: StoredBases = {
 		apiBase,
 		authBase,
-		mode,
-		updatedAt: new Date().toISOString(),
 	};
 	_cachedApiBase = apiBase;
 	_cachedAuthBase = authBase;

package/assets/extensions/seedclub/commands/seedclub.ts

@@ -41,7 +41,6 @@ async function showSeedEnvironment(ctx: any) {
 	const lines = [
 		`effective api: ${getApiBase()}`,
 		`effective auth: ${getAuthBase()}`,
-		`stored mode: ${storedBases?.mode ?? "none"}`,
 		`stored api: ${storedBases?.apiBase ?? "none"}`,
 		`stored auth: ${storedBases?.authBase ?? "none"}`,
 	];
@@ -50,7 +49,7 @@ async function showSeedEnvironment(ctx: any) {
 
 async function setSeedEnvironment(mode: "local" | "prod", ctx: any) {
 	const bases = getDefaultBases(mode);
-	await storeBases(bases.apiBase, bases.authBase, mode);
+	await storeBases(bases.apiBase, bases.authBase);
 	ctx.ui.notify(
 		`Seed Club environment set to ${mode}.\napi: ${bases.apiBase}\nauth: ${bases.authBase}\nReconnect if your current token belongs to a different environment.`,
 		"info",
@@ -113,13 +112,15 @@ export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
 			const isConnected = !!stored || hasEnvToken;
 
 			if (!isConnected) {
-				return await deps.connect(args, ctx);
+				await deps.connect(args, ctx);
+				return;
 			}
 
 			const user = await getCurrentUser();
 			if ("error" in user) {
 				ctx.ui.notify("Session expired. Reconnecting...", "info");
-				return await deps.connect(args, ctx);
+				await deps.connect(args, ctx);
+				return;
 			}
 
 			const session = await getSessionContext();

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,
+};

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

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	exactNormalizedTextMatch,
+	normalizePersonQuery,
+	parseDateHint,
+	parseIntent,
+	parseTimeFilter,
+	textToSyntheticVtt,
+} from "./transcript-export-helpers.js";
+
+test("normalizePersonQuery strips transcript artifact words", () => {
+	assert.equal(normalizePersonQuery("Vibhu transcripts"), "Vibhu");
+	assert.equal(normalizePersonQuery("recent captions"), undefined);
+});
+
+test("parseDateHint handles explicit calendar dates", () => {
+	assert.equal(parseDateHint("captions for Vibhu on March 2, 2026"), "2026-03-02");
+	assert.equal(parseDateHint("2026-04-24 transcripts"), "2026-04-24");
+});
+
+test("parseIntent captures person, date, explicit time, and output path", () => {
+	const intent = parseIntent("download Vibhu transcripts on March 2, 2026 at 14:00 to ~/Downloads/custom");
+	assert.deepEqual(intent, {
+		person: "Vibhu",
+		people: ["Vibhu"],
+		date: "2026-03-02",
+		time: "14:00",
+		outDir: "~/Downloads/custom",
+	});
+});
+
+test("parseIntent does not treat bare 11am program mention as a time filter", () => {
+	const intent = parseIntent("download Vibhu transcripts from 11am");
+	assert.equal(intent.person, "Vibhu");
+	assert.equal(intent.time, undefined);
+});
+
+test("parseTimeFilter supports 24 hour and 12 hour formats", () => {
+	assert.deepEqual(parseTimeFilter("14:00"), { hour: 14, minute: 0 });
+	assert.deepEqual(parseTimeFilter("2pm"), { hour: 14, minute: undefined });
+	assert.equal(parseTimeFilter("25:00"), null);
+});
+
+test("exactNormalizedTextMatch avoids partial-name false positives", () => {
+	assert.equal(exactNormalizedTextMatch("dan", "Jordan Walker on 11am"), false);
+	assert.equal(exactNormalizedTextMatch("rob", "Robert Leshner on 11am"), false);
+	assert.equal(exactNormalizedTextMatch("vibhu", "Vibhu Norby on 11am"), true);
+	assert.equal(exactNormalizedTextMatch("vibhu norby", "Vibhu Norby on 11am"), true);
+});
+
+test("textToSyntheticVtt generates a valid VTT envelope from transcript text", () => {
+	const vtt = textToSyntheticVtt("Host: Welcome back.\n\nGuest: Thanks for having me.");
+	assert.ok(vtt);
+	assert.match(vtt, /^WEBVTT\b/);
+	assert.match(vtt, /-->/);
+	assert.match(vtt, /Host: Welcome back\./);
+	assert.match(vtt, /Guest: Thanks for having me\./);
+});