birdclaw 0.1.0

package/src/lib/theme.tsx

@@ -0,0 +1,157 @@
+import {
+	createContext,
+	type ReactNode,
+	useContext,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+
+export type ThemeValue = "system" | "light" | "dark";
+export type ResolvedTheme = "light" | "dark";
+
+const THEME_STORAGE_KEY = "birdclaw-theme";
+
+interface ThemeContextValue {
+	isReady: boolean;
+	theme: ThemeValue;
+	resolvedTheme: ResolvedTheme;
+	setTheme: (theme: ThemeValue) => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+function getSystemTheme(): ResolvedTheme {
+	if (
+		typeof window === "undefined" ||
+		typeof window.matchMedia !== "function"
+	) {
+		return "light";
+	}
+	return window.matchMedia("(prefers-color-scheme: dark)").matches
+		? "dark"
+		: "light";
+}
+
+function resolveTheme(theme: ThemeValue): ResolvedTheme {
+	return theme === "system" ? getSystemTheme() : theme;
+}
+
+function applyThemeToDocument(theme: ThemeValue) {
+	if (typeof document === "undefined") return;
+
+	const resolvedTheme = resolveTheme(theme);
+	document.documentElement.dataset.themePreference = theme;
+	document.documentElement.dataset.theme = resolvedTheme;
+	document.documentElement.style.colorScheme = resolvedTheme;
+}
+
+function readInitialTheme(): ThemeValue {
+	if (typeof document !== "undefined") {
+		const value = document.documentElement.dataset.themePreference;
+		if (value === "light" || value === "dark" || value === "system") {
+			return value;
+		}
+	}
+
+	if (typeof window !== "undefined") {
+		const stored = window.localStorage.getItem(THEME_STORAGE_KEY);
+		if (stored === "light" || stored === "dark" || stored === "system") {
+			return stored;
+		}
+	}
+
+	return "system";
+}
+
+export const themeScript = `
+(() => {
+  const storageKey = "${THEME_STORAGE_KEY}";
+  const root = document.documentElement;
+  const stored = window.localStorage.getItem(storageKey);
+  const preference =
+    stored === "light" || stored === "dark" || stored === "system"
+      ? stored
+      : "system";
+  const resolved =
+    preference === "system"
+      ? window.matchMedia("(prefers-color-scheme: dark)").matches
+        ? "dark"
+        : "light"
+      : preference;
+  root.dataset.themePreference = preference;
+  root.dataset.theme = resolved;
+  root.style.colorScheme = resolved;
+})();
+`;
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+	const [theme, setThemeState] = useState<ThemeValue>("system");
+	const [resolvedTheme, setResolvedTheme] = useState<ResolvedTheme>("light");
+	const [isReady, setIsReady] = useState(false);
+
+	useEffect(() => {
+		const initialTheme = readInitialTheme();
+		setThemeState(initialTheme);
+		setResolvedTheme(resolveTheme(initialTheme));
+		applyThemeToDocument(initialTheme);
+		setIsReady(true);
+	}, []);
+
+	useEffect(() => {
+		if (!isReady) {
+			return;
+		}
+
+		applyThemeToDocument(theme);
+		setResolvedTheme(resolveTheme(theme));
+		window.localStorage.setItem(THEME_STORAGE_KEY, theme);
+
+		if (theme !== "system" || typeof window.matchMedia !== "function") {
+			return;
+		}
+
+		const media = window.matchMedia("(prefers-color-scheme: dark)");
+		const onChange = () => {
+			const nextResolvedTheme = media.matches ? "dark" : "light";
+			setResolvedTheme(nextResolvedTheme);
+			document.documentElement.dataset.theme = nextResolvedTheme;
+			document.documentElement.style.colorScheme = nextResolvedTheme;
+		};
+
+		if ("addEventListener" in media) {
+			media.addEventListener("change", onChange);
+		} else {
+			media.addListener(onChange);
+		}
+		return () => {
+			if ("removeEventListener" in media) {
+				media.removeEventListener("change", onChange);
+			} else {
+				media.removeListener(onChange);
+			}
+		};
+	}, [isReady, theme]);
+
+	const value = useMemo<ThemeContextValue>(
+		() => ({
+			isReady,
+			theme,
+			resolvedTheme,
+			setTheme: setThemeState,
+		}),
+		[isReady, resolvedTheme, theme],
+	);
+
+	return (
+		<ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>
+	);
+}
+
+export function useTheme() {
+	const context = useContext(ThemeContext);
+	if (!context) {
+		throw new Error("useTheme must be used within ThemeProvider");
+	}
+	return context;
+}

package/src/lib/tweet-render.ts

@@ -0,0 +1,115 @@
+import type {
+	TweetEntities,
+	TweetHashtagEntity,
+	TweetMentionEntity,
+	TweetUrlEntity,
+} from "./types";
+
+type TweetSegment =
+	| ({ kind: "mention" } & TweetMentionEntity)
+	| ({ kind: "url" } & TweetUrlEntity)
+	| ({ kind: "hashtag" } & TweetHashtagEntity);
+
+const MARKDOWN_ESCAPE_CHARACTERS = new Set([
+	"\\",
+	"`",
+	"*",
+	"_",
+	"{",
+	"}",
+	"[",
+	"]",
+	"(",
+	")",
+	"#",
+	"+",
+	".",
+	"!",
+	"|",
+	">",
+	"-",
+]);
+
+function escapeMarkdown(text: string) {
+	return [...text]
+		.map((character) =>
+			MARKDOWN_ESCAPE_CHARACTERS.has(character) ? `\\${character}` : character,
+		)
+		.join("");
+}
+
+export function collectTweetSegments(entities: TweetEntities): TweetSegment[] {
+	return [
+		...(entities.mentions?.map((entry) => ({
+			...entry,
+			kind: "mention" as const,
+		})) ?? []),
+		...(entities.urls?.map((entry) => ({ ...entry, kind: "url" as const })) ??
+			[]),
+		...(entities.hashtags?.map((entry) => ({
+			...entry,
+			kind: "hashtag" as const,
+		})) ?? []),
+	].sort((left, right) => left.start - right.start);
+}
+
+function renderTweetText(
+	text: string,
+	entities: TweetEntities,
+	renderSegment: (segment: TweetSegment, fallback: string) => string,
+) {
+	const segments = collectTweetSegments(entities);
+	let cursor = 0;
+	let output = "";
+
+	for (const segment of segments) {
+		if (
+			segment.start < cursor ||
+			segment.end <= segment.start ||
+			segment.end > text.length
+		) {
+			continue;
+		}
+
+		output += text.slice(cursor, segment.start);
+		const fallback = text.slice(segment.start, segment.end);
+		output += renderSegment(segment, fallback);
+		cursor = segment.end;
+	}
+
+	output += text.slice(cursor);
+	return output;
+}
+
+export function renderTweetPlainText(text: string, entities: TweetEntities) {
+	return renderTweetText(text, entities, (segment, fallback) => {
+		if (segment.kind === "url") {
+			return segment.expandedUrl;
+		}
+		if (segment.kind === "mention") {
+			return `@${segment.username}`;
+		}
+		if (segment.kind === "hashtag") {
+			return `#${segment.tag}`;
+		}
+		return fallback;
+	});
+}
+
+export function renderTweetMarkdown(text: string, entities: TweetEntities) {
+	return renderTweetText(text, entities, (segment, fallback) => {
+		if (segment.kind === "url") {
+			return `[${escapeMarkdown(segment.displayUrl)}](${segment.expandedUrl})`;
+		}
+		if (segment.kind === "mention") {
+			const label = `@${segment.username}`;
+			return segment.profile
+				? `[${escapeMarkdown(label)}](https://x.com/${segment.username})`
+				: escapeMarkdown(label);
+		}
+		if (segment.kind === "hashtag") {
+			return escapeMarkdown(`#${segment.tag}`);
+		}
+		return escapeMarkdown(fallback);
+	});
+}

package/src/lib/types.ts

@@ -0,0 +1,316 @@
+export type ResourceKind = "home" | "mentions" | "dms";
+export type InboxKind = "mixed" | "mentions" | "dms";
+
+export type ReplyFilter = "all" | "replied" | "unreplied";
+
+export interface AccountRecord {
+	id: string;
+	name: string;
+	handle: string;
+	transport: string;
+	isDefault: number;
+	createdAt: string;
+}
+
+export interface ProfileRecord {
+	id: string;
+	handle: string;
+	displayName: string;
+	bio: string;
+	followersCount: number;
+	avatarHue: number;
+	avatarUrl?: string;
+	createdAt: string;
+}
+
+export interface TweetMentionEntity {
+	username: string;
+	id?: string;
+	start: number;
+	end: number;
+	profile?: ProfileRecord;
+}
+
+export interface TweetUrlEntity {
+	url: string;
+	expandedUrl: string;
+	displayUrl: string;
+	start: number;
+	end: number;
+	title?: string;
+	description?: string | null;
+}
+
+export interface TweetHashtagEntity {
+	tag: string;
+	start: number;
+	end: number;
+}
+
+export interface TweetEntities {
+	mentions?: TweetMentionEntity[];
+	urls?: TweetUrlEntity[];
+	hashtags?: TweetHashtagEntity[];
+}
+
+export interface TweetMediaItem {
+	url: string;
+	type: "image" | "video" | "gif" | "unknown";
+	altText?: string;
+	width?: number;
+	height?: number;
+	thumbnailUrl?: string;
+}
+
+export interface EmbeddedTweet {
+	id: string;
+	text: string;
+	createdAt: string;
+	author: ProfileRecord;
+	entities: TweetEntities;
+	media: TweetMediaItem[];
+}
+
+export interface BlockItem {
+	accountId: string;
+	accountHandle: string;
+	source: string;
+	blockedAt: string;
+	profile: ProfileRecord;
+}
+
+export interface BlockSearchItem {
+	profile: ProfileRecord;
+	isBlocked: boolean;
+	blockedAt?: string;
+}
+
+export interface BlockListResponse {
+	items: BlockItem[];
+	matches: BlockSearchItem[];
+}
+
+export interface TimelineItem {
+	id: string;
+	accountId: string;
+	accountHandle: string;
+	kind: Exclude<ResourceKind, "dms">;
+	text: string;
+	createdAt: string;
+	isReplied: boolean;
+	likeCount: number;
+	mediaCount: number;
+	bookmarked: boolean;
+	liked: boolean;
+	author: ProfileRecord;
+	entities: TweetEntities;
+	media: TweetMediaItem[];
+	replyToTweet?: EmbeddedTweet | null;
+	quotedTweet?: EmbeddedTweet | null;
+}
+
+export interface DmMessageItem {
+	id: string;
+	conversationId: string;
+	text: string;
+	createdAt: string;
+	direction: "inbound" | "outbound";
+	isReplied: boolean;
+	mediaCount: number;
+	sender: ProfileRecord;
+}
+
+export interface DmConversationItem {
+	id: string;
+	accountId: string;
+	accountHandle: string;
+	title: string;
+	lastMessageAt: string;
+	lastMessagePreview: string;
+	unreadCount: number;
+	needsReply: boolean;
+	influenceScore: number;
+	influenceLabel: string;
+	participant: ProfileRecord;
+}
+
+export interface TimelineQuery {
+	resource: Exclude<ResourceKind, "dms">;
+	account?: string;
+	search?: string;
+	replyFilter?: ReplyFilter;
+	limit?: number;
+}
+
+export interface DmQuery {
+	account?: string;
+	participant?: string;
+	search?: string;
+	replyFilter?: ReplyFilter;
+	minFollowers?: number;
+	maxFollowers?: number;
+	minInfluenceScore?: number;
+	maxInfluenceScore?: number;
+	sort?: "recent" | "influence";
+	limit?: number;
+}
+
+export interface TransportStatus {
+	installed: boolean;
+	availableTransport: "xurl" | "local";
+	statusText: string;
+	rawStatus?: string;
+}
+
+export type ModerationAction = "block" | "unblock" | "mute" | "unmute";
+export type ModerationTransportKind = "bird" | "xurl";
+
+export interface ModerationActionTransportResult {
+	ok: boolean;
+	output: string;
+	transport: ModerationTransportKind;
+}
+
+export interface ArchiveCandidate {
+	path: string;
+	name: string;
+	size: number;
+	sizeFormatted: string;
+	modifiedTime: string;
+	dateFormatted: string;
+}
+
+export interface QueryEnvelope {
+	accounts: AccountRecord[];
+	archives: ArchiveCandidate[];
+	transport: TransportStatus;
+	stats: {
+		home: number;
+		mentions: number;
+		dms: number;
+		needsReply: number;
+		inbox: number;
+	};
+}
+
+export interface QueryResponse {
+	resource: ResourceKind;
+	items: TimelineItem[] | DmConversationItem[];
+	selectedConversation?: {
+		conversation: DmConversationItem;
+		messages: DmMessageItem[];
+	} | null;
+}
+
+export interface InboxItem {
+	id: string;
+	entityId: string;
+	entityKind: "mention" | "dm";
+	accountId: string;
+	accountHandle: string;
+	title: string;
+	text: string;
+	createdAt: string;
+	needsReply: boolean;
+	influenceScore: number;
+	participant: ProfileRecord;
+	source: "heuristic" | "openai";
+	score: number;
+	summary: string;
+	reasoning: string;
+}
+
+export interface InboxQuery {
+	kind?: InboxKind;
+	minScore?: number;
+	hideLowSignal?: boolean;
+	limit?: number;
+}
+
+export interface InboxResponse {
+	items: InboxItem[];
+	stats: {
+		total: number;
+		openai: number;
+		heuristic: number;
+	};
+}
+
+export interface XurlPublicMetrics {
+	retweet_count?: number;
+	reply_count?: number;
+	like_count?: number;
+	quote_count?: number;
+	bookmark_count?: number;
+	impression_count?: number;
+	followers_count?: number;
+}
+
+export interface XurlMentionUser {
+	id: string;
+	name: string;
+	username: string;
+	description?: string;
+	profile_image_url?: string;
+	public_metrics?: XurlPublicMetrics;
+	created_at?: string;
+}
+
+export interface XurlMentionData {
+	id: string;
+	author_id: string;
+	text: string;
+	created_at: string;
+	conversation_id?: string;
+	entities?: Record<string, unknown>;
+	public_metrics?: XurlPublicMetrics;
+	edit_history_tweet_ids?: string[];
+}
+
+export interface XurlReferencedTweet {
+	type: string;
+	id: string;
+}
+
+export interface XurlUserTweet {
+	id: string;
+	text: string;
+	created_at: string;
+	conversation_id?: string;
+	referenced_tweets?: XurlReferencedTweet[];
+	public_metrics?: XurlPublicMetrics;
+	edit_history_tweet_ids?: string[];
+}
+
+export interface ProfileReplyItem {
+	id: string;
+	text: string;
+	createdAt: string;
+	conversationId?: string;
+	replyToTweetId?: string;
+	likeCount: number;
+	replyCount: number;
+	retweetCount: number;
+	quoteCount: number;
+	bookmarkCount: number;
+	impressionCount: number;
+}
+
+export interface ProfileRepliesResponse {
+	profile: ProfileRecord;
+	externalUserId: string;
+	items: ProfileReplyItem[];
+	meta: {
+		scannedCount: number;
+		returnedCount: number;
+		nextToken: string | null;
+	};
+}
+
+export interface XurlMentionsResponse {
+	data: XurlMentionData[];
+	includes?: {
+		users?: XurlMentionUser[];
+	};
+	meta?: Record<string, unknown>;
+}