birdclaw 0.1.0

package/src/lib/inbox.ts

@@ -0,0 +1,210 @@
+import { getNativeDb } from "./db";
+import { scoreInboxItemWithOpenAI } from "./openai";
+import { listDmConversations, listTimelineItems } from "./queries";
+import type { InboxItem, InboxQuery, InboxResponse } from "./types";
+
+function heuristicSummary(kind: InboxItem["entityKind"]) {
+	return kind === "dm"
+		? "Ranked from reply pressure, influence, and recency."
+		: "Ranked from mention urgency, influence, and specificity.";
+}
+
+function getHeuristicScoreForMention(
+	item: ReturnType<typeof listTimelineItems>[number],
+) {
+	const influence = Math.min(
+		32,
+		Math.round(Math.log10(item.author.followersCount + 10) * 18),
+	);
+	const specificityBoost = item.text.includes("?") ? 8 : 0;
+	return Math.max(0, Math.min(100, 44 + influence + specificityBoost));
+}
+
+function getHeuristicScoreForDm(
+	item: ReturnType<typeof listDmConversations>[number],
+) {
+	const unreadBoost = Math.min(15, item.unreadCount * 5);
+	const replyBoost = item.needsReply ? 12 : 0;
+	return Math.max(
+		0,
+		Math.min(
+			100,
+			34 + Math.round(item.influenceScore * 0.32) + unreadBoost + replyBoost,
+		),
+	);
+}
+
+function readStoredScores() {
+	const db = getNativeDb();
+	const rows = db
+		.prepare(
+			`
+      select entity_kind, entity_id, model, score, summary, reasoning, updated_at
+      from ai_scores
+      `,
+		)
+		.all() as Array<Record<string, unknown>>;
+
+	return new Map(
+		rows.map((row) => [
+			`${row.entity_kind}:${row.entity_id}`,
+			{
+				model: String(row.model),
+				score: Number(row.score),
+				summary: String(row.summary),
+				reasoning: String(row.reasoning),
+				updatedAt: String(row.updated_at),
+			},
+		]),
+	);
+}
+
+export function listInboxItems({
+	kind = "mixed",
+	minScore = 0,
+	hideLowSignal = false,
+	limit = 20,
+}: InboxQuery = {}): InboxResponse {
+	const storedScores = readStoredScores();
+	const items: InboxItem[] = [];
+
+	if (kind === "mixed" || kind === "mentions") {
+		for (const mention of listTimelineItems({
+			resource: "mentions",
+			replyFilter: "unreplied",
+			limit: 50,
+		})) {
+			const scoreKey = `mention:${mention.id}`;
+			const stored = storedScores.get(scoreKey);
+			items.push({
+				id: scoreKey,
+				entityId: mention.id,
+				entityKind: "mention",
+				accountId: mention.accountId,
+				accountHandle: mention.accountHandle,
+				title: `Mention from ${mention.author.displayName}`,
+				text: mention.text,
+				createdAt: mention.createdAt,
+				needsReply: !mention.isReplied,
+				influenceScore: Math.round(
+					Math.log10(mention.author.followersCount + 10) * 24,
+				),
+				participant: mention.author,
+				source: stored ? "openai" : "heuristic",
+				score: stored?.score ?? getHeuristicScoreForMention(mention),
+				summary: stored?.summary ?? heuristicSummary("mention"),
+				reasoning:
+					stored?.reasoning ??
+					`@${mention.author.handle} · ${mention.author.followersCount} followers`,
+			});
+		}
+	}
+
+	if (kind === "mixed" || kind === "dms") {
+		for (const dm of listDmConversations({
+			replyFilter: "unreplied",
+			sort: "influence",
+			limit: 50,
+		})) {
+			const scoreKey = `dm:${dm.id}`;
+			const stored = storedScores.get(scoreKey);
+			items.push({
+				id: scoreKey,
+				entityId: dm.id,
+				entityKind: "dm",
+				accountId: dm.accountId,
+				accountHandle: dm.accountHandle,
+				title: `DM from ${dm.participant.displayName}`,
+				text: dm.lastMessagePreview,
+				createdAt: dm.lastMessageAt,
+				needsReply: dm.needsReply,
+				influenceScore: dm.influenceScore,
+				participant: dm.participant,
+				source: stored ? "openai" : "heuristic",
+				score: stored?.score ?? getHeuristicScoreForDm(dm),
+				summary: stored?.summary ?? heuristicSummary("dm"),
+				reasoning:
+					stored?.reasoning ??
+					`@${dm.participant.handle} · ${dm.participant.followersCount} followers`,
+			});
+		}
+	}
+
+	const lowSignalFloor = hideLowSignal ? Math.max(40, minScore) : minScore;
+	const filtered = items
+		.filter((item) => item.score >= lowSignalFloor)
+		.sort((left, right) => {
+			if (right.score !== left.score) return right.score - left.score;
+			return (
+				new Date(right.createdAt).getTime() - new Date(left.createdAt).getTime()
+			);
+		})
+		.slice(0, limit);
+
+	return {
+		items: filtered,
+		stats: {
+			total: filtered.length,
+			openai: filtered.filter((item) => item.source === "openai").length,
+			heuristic: filtered.filter((item) => item.source === "heuristic").length,
+		},
+	};
+}
+
+export async function scoreInbox({
+	kind = "mixed",
+	limit = 8,
+}: Pick<InboxQuery, "kind" | "limit"> = {}) {
+	const db = getNativeDb();
+	const items = listInboxItems({ kind, limit }).items;
+	const results = [];
+
+	for (const item of items) {
+		const scored = await scoreInboxItemWithOpenAI({
+			entityKind: item.entityKind,
+			title: item.title,
+			text: item.text,
+			influenceScore: item.influenceScore,
+			participant: {
+				handle: item.participant.handle,
+				displayName: item.participant.displayName,
+				bio: item.participant.bio,
+				followersCount: item.participant.followersCount,
+			},
+		});
+
+		db.prepare(
+			`
+      insert into ai_scores (
+        entity_kind, entity_id, model, score, summary, reasoning, updated_at
+      ) values (?, ?, ?, ?, ?, ?, ?)
+      on conflict(entity_kind, entity_id) do update set
+        model = excluded.model,
+        score = excluded.score,
+        summary = excluded.summary,
+        reasoning = excluded.reasoning,
+        updated_at = excluded.updated_at
+      `,
+		).run(
+			item.entityKind,
+			item.entityId,
+			scored.model,
+			scored.score,
+			scored.summary,
+			scored.reasoning,
+			new Date().toISOString(),
+		);
+
+		results.push({
+			id: item.id,
+			score: scored.score,
+			source: "openai",
+		});
+	}
+
+	return {
+		ok: true,
+		scored: results.length,
+		items: results,
+	};
+}

package/src/lib/mentions-export.ts

@@ -0,0 +1,147 @@
+import { listTimelineItems } from "./queries";
+import { renderTweetMarkdown, renderTweetPlainText } from "./tweet-render";
+import type {
+	ReplyFilter,
+	TimelineItem,
+	XurlMentionData,
+	XurlMentionsResponse,
+	XurlMentionUser,
+} from "./types";
+
+export interface MentionExportItem {
+	id: string;
+	url: string;
+	createdAt: string;
+	accountId: string;
+	accountHandle: string;
+	isReplied: boolean;
+	author: TimelineItem["author"];
+	text: string;
+	plainText: string;
+	markdown: string;
+	likeCount: number;
+	mediaCount: number;
+	bookmarked: boolean;
+	liked: boolean;
+	replyToTweetId?: string | null;
+	quotedTweetId?: string | null;
+}
+
+function toXurlUserId(profileId: string) {
+	if (profileId.startsWith("profile_user_")) {
+		return profileId.replace(/^profile_user_/, "");
+	}
+	return profileId;
+}
+
+function toXurlEntities(item: TimelineItem) {
+	const mentions = item.entities.mentions?.map((mention) => ({
+		start: mention.start,
+		end: mention.end,
+		username: mention.profile?.handle ?? mention.username,
+		...(mention.id ? { id: toXurlUserId(mention.id) } : {}),
+	}));
+	const urls = item.entities.urls?.map((url) => ({
+		start: url.start,
+		end: url.end,
+		url: url.url,
+		expanded_url: url.expandedUrl,
+		display_url: url.displayUrl,
+	}));
+
+	if (!mentions?.length && !urls?.length) {
+		return undefined;
+	}
+
+	return {
+		...(mentions?.length ? { mentions } : {}),
+		...(urls?.length ? { urls } : {}),
+	};
+}
+
+export function exportMentionItems({
+	account,
+	search,
+	replyFilter = "all",
+	limit = 20,
+}: {
+	account?: string;
+	search?: string;
+	replyFilter?: ReplyFilter;
+	limit?: number;
+}) {
+	const items = listTimelineItems({
+		resource: "mentions",
+		account,
+		search,
+		replyFilter,
+		limit,
+	});
+
+	return items.map(
+		(item): MentionExportItem => ({
+			id: item.id,
+			url: `https://x.com/${item.author.handle}/status/${item.id}`,
+			createdAt: item.createdAt,
+			accountId: item.accountId,
+			accountHandle: item.accountHandle,
+			isReplied: item.isReplied,
+			author: item.author,
+			text: item.text,
+			plainText: renderTweetPlainText(item.text, item.entities),
+			markdown: renderTweetMarkdown(item.text, item.entities),
+			likeCount: item.likeCount,
+			mediaCount: item.mediaCount,
+			bookmarked: item.bookmarked,
+			liked: item.liked,
+			replyToTweetId: item.replyToTweet?.id ?? null,
+			quotedTweetId: item.quotedTweet?.id ?? null,
+		}),
+	);
+}
+
+export function serializeMentionItemsAsXurlCompatible(
+	items: TimelineItem[],
+): XurlMentionsResponse {
+	const users = new Map<string, XurlMentionUser>();
+	const data = items.map((item): XurlMentionData => {
+		const authorId = toXurlUserId(item.author.id);
+		users.set(authorId, {
+			id: authorId,
+			name: item.author.displayName,
+			username: item.author.handle,
+		});
+
+		const metrics = {
+			retweet_count: 0,
+			reply_count: item.isReplied ? 1 : 0,
+			like_count: item.likeCount,
+			quote_count: 0,
+			bookmark_count: item.bookmarked ? 1 : 0,
+			impression_count: 0,
+		};
+
+		return {
+			id: item.id,
+			author_id: authorId,
+			text: item.text,
+			created_at: item.createdAt,
+			conversation_id: item.replyToTweet?.id ?? item.id,
+			entities: toXurlEntities(item),
+			public_metrics: metrics,
+			edit_history_tweet_ids: [item.id],
+		};
+	});
+
+	return {
+		data,
+		includes: {
+			users: Array.from(users.values()),
+		},
+		meta: {
+			result_count: data.length,
+			...(data[0] ? { newest_id: data[0].id } : {}),
+			...(data.at(-1) ? { oldest_id: data.at(-1)?.id } : {}),
+		},
+	};
+}