@clubnet/seedclub 0.2.0

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

@@ -0,0 +1,601 @@
+/**
+ * /add — add signals from URLs, @handles, or your Twitter activity.
+ *
+ * Every signal is a URL. Content on the internet.
+ *
+ * URLs/@handles → created instantly
+ * "my bookmarks" → each bookmarked tweet is a signal (the tweet URL)
+ * "my likes" → each liked tweet is a signal (the tweet URL)
+ * "who I follow" → each account is a signal (the profile URL)
+ */
+
+import { randomBytes } from "node:crypto";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { api } from "../api-client.js";
+import { getApiBase } from "../auth.js";
+import { createSignal, importSignals } from "../tools/signals.js";
+import { checkTwitterCredentials, getTwitterClient } from "../twitter-client.js";
+
+interface Signal {
+	type: string;
+	name: string;
+	externalUrl: string;
+	description?: string;
+	metadata?: Record<string, unknown>;
+}
+
+// ────────────────────────────────────────
+// URL/handle parsing
+// ────────────────────────────────────────
+
+function tryParseUrls(raw: string): Signal[] | null {
+	const tokens = raw
+		.split(/[,\n]+/)
+		.flatMap((s) => s.trim().split(/\s+/))
+		.filter(Boolean);
+
+	const results: Signal[] = [];
+	for (const token of tokens) {
+		const signal = classifyUrl(token);
+		if (!signal) return null; // one bad token = not a URL list
+		results.push(signal);
+	}
+	return results.length > 0 ? results : null;
+}
+
+function classifyUrl(s: string): Signal | null {
+	s = s.trim();
+
+	// @handle
+	if (s.startsWith("@")) {
+		const handle = s.slice(1).replace(/\/$/, "");
+		return { type: "twitter_account", name: handle, externalUrl: `https://x.com/${handle}`, metadata: { handle } };
+	}
+
+	// x.com / twitter.com tweet URLs (must check before profile)
+	const tweet = s.match(/(?:x\.com|twitter\.com)\/([a-zA-Z0-9_]+)\/status\/(\d+)/);
+	if (tweet) {
+		const url = `https://x.com/${tweet[1]}/status/${tweet[2]}`;
+		return {
+			type: "twitter_account",
+			name: `Tweet by @${tweet[1]}`,
+			externalUrl: url,
+			metadata: { handle: tweet[1], tweetId: tweet[2] },
+		};
+	}
+
+	// x.com / twitter.com profile URLs
+	const tw = s.match(/(?:x\.com|twitter\.com)\/([a-zA-Z0-9_]+)\/?(?:\?.*)?$/);
+	if (tw) {
+		return {
+			type: "twitter_account",
+			name: tw[1],
+			externalUrl: `https://x.com/${tw[1]}`,
+			metadata: { handle: tw[1] },
+		};
+	}
+
+	// GitHub
+	const gh = s.match(/github\.com\/([a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_.-]+)?)/);
+	if (gh) return { type: "github_profile", name: gh[1], externalUrl: `https://github.com/${gh[1]}` };
+
+	// Substack
+	const ss = s.match(/([a-zA-Z0-9-]+)\.substack\.com/);
+	if (ss)
+		return {
+			type: "newsletter",
+			name: ss[1].replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+			externalUrl: s.startsWith("http") ? s : `https://${s}`,
+		};
+
+	// Reddit
+	const rd = s.match(/r\/([a-zA-Z0-9_]+)/);
+	if (rd) return { type: "subreddit", name: `r/${rd[1]}`, externalUrl: `https://reddit.com/r/${rd[1]}` };
+
+	// Any other URL
+	if (s.includes("://") || s.match(/^[a-zA-Z0-9-]+\.[a-z]{2,}/)) {
+		const url = s.startsWith("http") ? s : `https://${s}`;
+		const domain = url
+			.replace(/https?:\/\//, "")
+			.replace(/\/.*/, "")
+			.replace(/^www\./, "");
+		const name = domain
+			.split(".")[0]
+			.replace(/-/g, " ")
+			.replace(/\b\w/g, (c) => c.toUpperCase());
+		return { type: "blog", name, externalUrl: url };
+	}
+
+	return null;
+}
+
+// ────────────────────────────────────────
+// Twitter query parsing
+// ────────────────────────────────────────
+
+interface TwitterQuery {
+	action: "likes" | "bookmarks" | "following" | "search";
+	count?: number;
+	query?: string;
+	since?: Date;
+	author?: string; // filter by @username
+}
+
+const MONTHS = [
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december",
+];
+
+const WORD_NUMBERS: Record<string, number> = {
+	one: 1,
+	two: 2,
+	three: 3,
+	four: 4,
+	five: 5,
+	six: 6,
+	seven: 7,
+	eight: 8,
+	nine: 9,
+	ten: 10,
+	eleven: 11,
+	twelve: 12,
+};
+
+function _parseNumber(s: string): number | undefined {
+	const digitMatch = s.match(/(\d+)/);
+	if (digitMatch) return parseInt(digitMatch[1], 10);
+	for (const [word, num] of Object.entries(WORD_NUMBERS)) {
+		if (s.includes(word)) return num;
+	}
+	return undefined;
+}
+
+function parseDateFilter(s: string): Date | undefined {
+	const now = new Date();
+
+	// "from 2024" / "from 2025" — just a year
+	const justYear = s.match(/(?:from|since|in)\s+(20\d{2})(?:\s|$)/);
+	if (justYear) return new Date(parseInt(justYear[1], 10), 0, 1);
+
+	// "from november 2025" / "since march"
+	for (let i = 0; i < MONTHS.length; i++) {
+		if (s.includes(MONTHS[i])) {
+			const yearMatch = s.match(/\b(20\d{2})\b/);
+			const year = yearMatch
+				? parseInt(yearMatch[1], 10)
+				: i > now.getMonth()
+					? now.getFullYear() - 1
+					: now.getFullYear();
+			return new Date(year, i, 1);
+		}
+	}
+
+	// "last 3 months" / "last three months"
+	const monthsAgo = s.match(/last\s+(\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+months?/);
+	if (monthsAgo) {
+		const n = WORD_NUMBERS[monthsAgo[1]] || parseInt(monthsAgo[1], 10);
+		const d = new Date(now);
+		d.setMonth(d.getMonth() - n);
+		return d;
+	}
+
+	// "last 2 weeks" / "last two weeks"
+	const weeksAgo = s.match(/last\s+(\d+|one|two|three|four)\s+weeks?/);
+	if (weeksAgo) {
+		const n = WORD_NUMBERS[weeksAgo[1]] || parseInt(weeksAgo[1], 10);
+		return new Date(now.getTime() - n * 7 * 86400000);
+	}
+
+	if (s.includes("last week")) return new Date(now.getTime() - 7 * 86400000);
+	if (s.includes("last month")) {
+		const d = new Date(now);
+		d.setMonth(d.getMonth() - 1);
+		return d;
+	}
+	if (s.includes("last year")) {
+		const d = new Date(now);
+		d.setFullYear(d.getFullYear() - 1);
+		return d;
+	}
+	return undefined;
+}
+
+function parseTwitterQuery(input: string): TwitterQuery | null {
+	const s = input.toLowerCase().trim();
+
+	// Likes
+	if (s.match(/likes?/)) {
+		const since = parseDateFilter(s);
+		const author = parseAuthorFilter(s);
+		// Only grab a number as count if it's NOT a year and NOT part of "N months/weeks"
+		const countMatch = s.match(/(?:last\s+)?(\d+)\s*(?:likes?|bookmarks?)/);
+		const count = since ? 200 : countMatch ? parseInt(countMatch[1], 10) : 20;
+		return { action: "likes", count, since, author };
+	}
+
+	// Bookmarks
+	if (s.match(/bookmarks?/)) {
+		const since = parseDateFilter(s);
+		const author = parseAuthorFilter(s);
+		const countMatch = s.match(/(?:last\s+)?(\d+)\s*(?:likes?|bookmarks?)/);
+		const count = since ? 200 : countMatch ? parseInt(countMatch[1], 10) : 20;
+		return { action: "bookmarks", count, since, author };
+	}
+
+	// Following
+	if (s.match(/who\s+i\s+follow|my\s+following|following/)) {
+		return { action: "following", count: 50 };
+	}
+
+	// Search
+	const searchMatch = s.match(/(?:search|tweets?\s+about)\s+(.+)/);
+	if (searchMatch) {
+		return { action: "search", query: searchMatch[1], count: 20 };
+	}
+
+	return null;
+}
+
+function parseAuthorFilter(s: string): string | undefined {
+	const m = s.match(/(?:from|by)\s+@?([a-zA-Z0-9_]+)/);
+	if (
+		m &&
+		![
+			"last",
+			"the",
+			"my",
+			"november",
+			"december",
+			"january",
+			"february",
+			"march",
+			"april",
+			"may",
+			"june",
+			"july",
+			"august",
+			"september",
+			"october",
+			"2024",
+			"2025",
+			"2026",
+		].includes(m[1].toLowerCase())
+	) {
+		return m[1];
+	}
+	return undefined;
+}
+
+// ────────────────────────────────────────
+// Tweet → Signal conversion
+// ────────────────────────────────────────
+
+/** Each tweet becomes a signal — the URL is the tweet itself. */
+function tweetsToSignals(tweets: any[]): Signal[] {
+	const seen = new Set<string>();
+	const signals: Signal[] = [];
+
+	for (const tweet of tweets) {
+		const username = tweet.author?.username || tweet.authorUsername;
+		const tweetId = tweet.id || tweet.tweetId;
+		if (!username || !tweetId) continue;
+
+		const url = `https://x.com/${username}/status/${tweetId}`;
+		if (seen.has(url)) continue;
+		seen.add(url);
+
+		const text = tweet.text || tweet.fullText || "";
+
+		signals.push({
+			type: "twitter_account",
+			name: `@${username}`,
+			externalUrl: url,
+			description: text || undefined,
+			metadata: {
+				handle: username,
+				tweetId,
+				authorName: tweet.author?.name || tweet.authorName,
+				createdAt: tweet.createdAt,
+				likeCount: tweet.likeCount,
+				retweetCount: tweet.retweetCount,
+			},
+		});
+	}
+	return signals;
+}
+
+/** Following/followers → account signals */
+function usersToSignals(users: any[]): Signal[] {
+	return users.map((u: any) => ({
+		type: "twitter_account",
+		name: u.username || u.name,
+		externalUrl: `https://x.com/${u.username}`,
+		metadata: { handle: u.username },
+	}));
+}
+
+function filterTweets(tweets: any[], query: TwitterQuery): any[] {
+	let result = tweets;
+	if (query.since) result = result.filter((t: any) => new Date(t.createdAt) >= query.since!);
+	if (query.author) {
+		const a = query.author.toLowerCase();
+		result = result.filter((t: any) => (t.author?.username || t.authorUsername || "").toLowerCase() === a);
+	}
+	return result;
+}
+
+function filterLabel(query: TwitterQuery): string {
+	const parts: string[] = [];
+	if (query.since) parts.push(`since ${query.since.toLocaleDateString()}`);
+	if (query.author) parts.push(`from @${query.author}`);
+	return parts.length ? ` (${parts.join(", ")})` : "";
+}
+
+// ────────────────────────────────────────
+// Twitter auth
+// ────────────────────────────────────────
+
+async function ensureTwitterAuth(pi: ExtensionAPI, ctx: any): Promise<boolean> {
+	let twitterConnected = false;
+	try {
+		const user = await api.get<any>("/user");
+		twitterConnected = !!user.user?.twitterConnected;
+	} catch {}
+
+	if (!twitterConnected) {
+		ctx.ui.notify("Connecting your Twitter account...", "info");
+		const connected = await connectTwitterViaBrowser(pi, ctx);
+		if (!connected) return false;
+	}
+
+	const check = await checkTwitterCredentials();
+	if (!check.valid) {
+		ctx.ui.notify("Log in to x.com in your default browser, then try again.", "info");
+		return false;
+	}
+
+	return true;
+}
+
+async function connectTwitterViaBrowser(pi: ExtensionAPI, ctx: any): Promise<boolean> {
+	const apiBase = getApiBase();
+	const port = await findAvailablePort();
+	const state = randomBytes(16).toString("hex");
+	const authUrl = `${apiBase}/auth/cli/twitter?port=${port}&state=${state}`;
+
+	const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+	pi.exec(openCmd, [authUrl]).catch(() => {
+		ctx.ui.notify(`Open this link to connect Twitter:\n${authUrl}`, "info");
+	});
+
+	try {
+		await waitForTwitterCallback(port, state);
+		ctx.ui.notify("Twitter connected.", "info");
+		return true;
+	} catch (err: any) {
+		if (err.message === "cancelled") {
+			ctx.ui.notify("Twitter connection cancelled.", "info");
+		} else {
+			ctx.ui.notify(err.message || "Twitter connection failed.", "error");
+		}
+		return false;
+	}
+}
+
+function findAvailablePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			if (addr && typeof addr === "object") {
+				server.close(() => resolve(addr.port));
+			} else {
+				reject(new Error("Could not find available port"));
+			}
+		});
+		server.on("error", reject);
+	});
+}
+
+function waitForTwitterCallback(port: number, state: string): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			server.close();
+			reject(new Error("Timed out."));
+		}, 300_000);
+
+		const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+			const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404);
+				res.end();
+				return;
+			}
+
+			const done = (body: string) => {
+				res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(body);
+				clearTimeout(timeout);
+				server.close();
+			};
+
+			if (url.searchParams.get("state") !== state) {
+				done("<h1>Invalid state</h1>");
+				reject(new Error("Invalid state"));
+				return;
+			}
+			if (url.searchParams.get("error")) {
+				done("<h1>Cancelled</h1><p>You can close this tab.</p>");
+				reject(new Error(url.searchParams.get("error")!));
+				return;
+			}
+
+			done("<h1>Twitter connected</h1><p>You can close this tab.</p>");
+			resolve();
+		});
+
+		server.listen(port, "127.0.0.1");
+		server.on("error", (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+	});
+}
+
+// ────────────────────────────────────────
+// Create signals (batch or single)
+// ────────────────────────────────────────
+
+async function addSignals(signals: Signal[], ctx: any): Promise<void> {
+	if (signals.length === 0) {
+		ctx.ui.notify("Nothing to add.", "info");
+		return;
+	}
+
+	// If signals have metadata/description, use individual creates to preserve it
+	const hasRichData = signals.some((s) => s.description || s.metadata);
+
+	if (!hasRichData && signals.length >= 3) {
+		// Plain URL import (fast batch)
+		const input = signals.map((s) => s.externalUrl).join("\n");
+		const result = await importSignals({ input });
+		if ("error" in result) {
+			ctx.ui.notify(result.error, "error");
+		} else {
+			ctx.ui.notify(`${result.created} added, ${result.skipped} skipped`, "info");
+		}
+		return;
+	}
+
+	// Individual creates to preserve description + metadata
+	let created = 0;
+	let skipped = 0;
+	for (const signal of signals) {
+		const result = await createSignal(signal as any);
+		if ("error" in result) {
+			skipped++;
+		} else {
+			created++;
+		}
+	}
+	ctx.ui.notify(`${created} added${skipped > 0 ? `, ${skipped} skipped` : ""}`, "info");
+}
+
+// ────────────────────────────────────────
+// Execute Twitter query
+// ────────────────────────────────────────
+
+async function executeTwitterQuery(query: TwitterQuery, ctx: any): Promise<void> {
+	const client = await getTwitterClient();
+	ctx.ui.notify(`Fetching ${query.action}...`, "info");
+
+	switch (query.action) {
+		case "likes": {
+			const r = await client.getLikes(query.count || 20);
+			if (!r.success) {
+				ctx.ui.notify(r.error || "Failed to fetch likes", "error");
+				return;
+			}
+			const tweets = filterTweets(r.tweets || [], query);
+			ctx.ui.notify(`Found ${tweets.length} likes${filterLabel(query)}`, "info");
+			await addSignals(tweetsToSignals(tweets), ctx);
+			return;
+		}
+
+		case "bookmarks": {
+			const r = await client.getBookmarks(query.count || 20);
+			if (!r.success) {
+				ctx.ui.notify(r.error || "Failed to fetch bookmarks", "error");
+				return;
+			}
+			const tweets = filterTweets(r.tweets || [], query);
+			ctx.ui.notify(`Found ${tweets.length} bookmarks${filterLabel(query)}`, "info");
+			await addSignals(tweetsToSignals(tweets), ctx);
+			return;
+		}
+
+		case "following": {
+			const me = await client.getCurrentUser();
+			if (!me.success || !me.user) {
+				ctx.ui.notify("Failed to get current user", "error");
+				return;
+			}
+			const r = await client.getFollowing(me.user.id, query.count || 50);
+			if (!r.success) {
+				ctx.ui.notify(r.error || "Failed to fetch following", "error");
+				return;
+			}
+			await addSignals(usersToSignals(r.users || []), ctx);
+			return;
+		}
+
+		case "search": {
+			const r = await client.search(query.query!, query.count || 20);
+			if (!r.success) {
+				ctx.ui.notify(r.error || "Search failed", "error");
+				return;
+			}
+			await addSignals(tweetsToSignals(r.tweets || []), ctx);
+			return;
+		}
+	}
+}
+
+// ────────────────────────────────────────
+// Registration
+// ────────────────────────────────────────
+
+export function registerAddInterceptor(pi: ExtensionAPI) {
+	pi.on("input", async (event, ctx) => {
+		if (!event.text.startsWith("/add ") && event.text !== "/add") {
+			return { action: "continue" as const };
+		}
+
+		const raw = event.text.slice(4).trim();
+		if (!raw) {
+			ctx.ui.notify(
+				"Usage:\n  /add @handle\n  /add https://example.com\n  /add my bookmarks\n  /add my last 10 likes\n  /add who I follow",
+				"info",
+			);
+			return { action: "handled" as const };
+		}
+
+		// URLs and @handles — instant
+		const urlSignals = tryParseUrls(raw);
+		if (urlSignals) {
+			await addSignals(urlSignals, ctx);
+			return { action: "handled" as const };
+		}
+
+		// Twitter natural language
+		const twitterQuery = parseTwitterQuery(raw);
+		if (twitterQuery) {
+			const authed = await ensureTwitterAuth(pi, ctx);
+			if (!authed) return { action: "handled" as const };
+			try {
+				await executeTwitterQuery(twitterQuery, ctx);
+			} catch (err: any) {
+				ctx.ui.notify(err.message || "Twitter request failed", "error");
+			}
+			return { action: "handled" as const };
+		}
+
+		// Unknown
+		ctx.ui.notify(
+			"Not sure what that is. Try:\n  /add @handle\n  /add https://example.com\n  /add my bookmarks\n  /add my last 10 likes\n  /add who I follow",
+			"info",
+		);
+		return { action: "handled" as const };
+	});
+}

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

@@ -0,0 +1,67 @@
+/**
+ * /seedclub — the main menu.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getStoredToken } from "../auth.js";
+import { getUnsortedSignals } from "../tools/signals.js";
+import { getCurrentUser } from "../tools/utility.js";
+import { runSortFlow } from "./sort.js";
+
+interface SeedclubDeps {
+	connect: (args: string | undefined, ctx: any) => Promise<void>;
+	disconnect: (ctx: any) => Promise<void>;
+}
+
+export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
+	pi.registerCommand("seedclub", {
+		description: "Seed Club",
+		handler: async (args, ctx) => {
+			const stored = await getStoredToken();
+			const hasEnvToken = !!process.env.SEEDCLUB_TOKEN || !!process.env.SEED_NETWORK_TOKEN;
+			const isConnected = !!stored || hasEnvToken;
+
+			if (!isConnected) {
+				return await deps.connect(args, ctx);
+			}
+
+			const user = await getCurrentUser();
+			if ("error" in user) {
+				ctx.ui.notify("Session expired. Reconnecting...", "info");
+				return await deps.connect(args, ctx);
+			}
+
+			// Main menu
+			let unsortedCount = "?";
+			let unsortedResult: any = null;
+			try {
+				const result = await getUnsortedSignals();
+				if (!("error" in result)) {
+					unsortedResult = result;
+					unsortedCount = String(result.unsortedCount ?? result.unsorted?.length ?? 0);
+				}
+			} catch {}
+
+			const sortLabel =
+				unsortedCount === "0" ? "Sort signals (all sorted)" : `Sort signals (${unsortedCount} unsorted)`;
+
+			const choice = await ctx.ui.select(user.name, ["Add signals", sortLabel, "---", "Disconnect"]);
+
+			if (!choice || choice === "---") return;
+
+			if (choice.startsWith("Sort signals")) {
+				return await runSortFlow(pi, ctx, unsortedResult);
+			}
+
+			switch (choice) {
+				case "Add signals":
+					await new Promise((r) => setTimeout(r, 300));
+					ctx.ui.setEditorText("/add ");
+					break;
+				case "Disconnect":
+					await deps.disconnect(ctx);
+					break;
+			}
+		},
+	});
+}