birdclaw 0.1.0 → 0.2.0

package/src/components/SavedTimelineView.tsx

@@ -0,0 +1,115 @@
+import { useEffect, useMemo, useState } from "react";
+import { TimelineCard } from "#/components/TimelineCard";
+import type { QueryEnvelope, QueryResponse, TimelineItem } from "#/lib/types";
+import {
+	cx,
+	eyebrowClass,
+	feedPageClass,
+	heroControlsClass,
+	heroCopyClass,
+	heroShellClass,
+	heroTitleClass,
+	pageWrapClass,
+	textFieldClass,
+	textFieldWideClass,
+	timelineLaneClass,
+} from "#/lib/ui";
+
+interface SavedTimelineViewProps {
+	filter: "liked" | "bookmarked";
+	eyebrow: string;
+	title: string;
+	loadingLabel: string;
+	searchPlaceholder: string;
+}
+
+export function SavedTimelineView({
+	filter,
+	eyebrow,
+	title,
+	loadingLabel,
+	searchPlaceholder,
+}: SavedTimelineViewProps) {
+	const [meta, setMeta] = useState<QueryEnvelope | null>(null);
+	const [items, setItems] = useState<TimelineItem[]>([]);
+	const [search, setSearch] = useState("");
+	const [refreshTick, setRefreshTick] = useState(0);
+
+	useEffect(() => {
+		fetch("/api/status")
+			.then((response) => response.json())
+			.then((data: QueryEnvelope) => setMeta(data));
+	}, []);
+
+	useEffect(() => {
+		const url = new URL("/api/query", window.location.origin);
+		url.searchParams.set("resource", "home");
+		url.searchParams.set(filter, "true");
+		url.searchParams.set("refresh", String(refreshTick));
+		if (search.trim()) {
+			url.searchParams.set("search", search.trim());
+		}
+
+		fetch(url)
+			.then((response) => response.json())
+			.then((data: QueryResponse) => setItems(data.items as TimelineItem[]));
+	}, [filter, refreshTick, search]);
+
+	const subtitle = useMemo(() => {
+		if (!meta) {
+			return items.length > 0 ? `${items.length} visible` : loadingLabel;
+		}
+		return `${items.length} visible · ${meta.transport.statusText}`;
+	}, [items.length, loadingLabel, meta]);
+
+	async function replyToTweet(tweetId: string) {
+		const text = window.prompt("Reply text");
+		if (!text?.trim()) return;
+
+		await fetch("/api/action", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				kind: "replyTweet",
+				accountId: "acct_primary",
+				tweetId,
+				text,
+			}),
+		});
+
+		setRefreshTick((value) => value + 1);
+	}
+
+	return (
+		<main className={pageWrapClass}>
+			<div className={feedPageClass}>
+				<section className={heroShellClass}>
+					<div>
+						<p className={eyebrowClass}>{eyebrow}</p>
+						<h2 className={heroTitleClass}>{title}</h2>
+						<p className={heroCopyClass}>{subtitle}</p>
+					</div>
+					<div className={heroControlsClass}>
+						<input
+							className={cx(textFieldClass, textFieldWideClass)}
+							onChange={(event) => setSearch(event.target.value)}
+							placeholder={searchPlaceholder}
+							value={search}
+						/>
+					</div>
+				</section>
+
+				<section className={timelineLaneClass}>
+					{items.map((item) => (
+						<TimelineCard
+							key={item.id}
+							item={item}
+							onReply={replyToTweet}
+							showReplyControls={false}
+						/>
+					))}
+				</section>
+			</div>
+		</main>
+	);
+}

package/src/components/TimelineCard.tsx

@@ -34,10 +34,15 @@ function getVisibleUrlCards(item: TimelineItem) {
 export function TimelineCard({
 	item,
 	onReply,
+	showReplyControls = true,
 }: {
 	item: TimelineItem;
 	onReply: (tweetId: string) => void;
+	showReplyControls?: boolean;
 }) {
+	const canReply =
+		showReplyControls && item.kind !== "like" && item.kind !== "bookmark";
+
 	return (
 		<article className={contentCardClass}>
 			<header className={cardHeaderClass}>
@@ -62,14 +67,16 @@ export function TimelineCard({
 					</div>
 				</div>
 				<div className={metaStackClass}>
-					<span
-						className={cx(
-							pillClass,
-							item.isReplied ? pillSoftClass : pillAlertClass,
-						)}
-					>
-						{item.isReplied ? "replied" : "needs reply"}
-					</span>
+					{canReply ? (
+						<span
+							className={cx(
+								pillClass,
+								item.isReplied ? pillSoftClass : pillAlertClass,
+							)}
+						>
+							{item.isReplied ? "replied" : "needs reply"}
+						</span>
+					) : null}
 					<span className={timestampClass}>
 						{formatShortTimestamp(item.createdAt)}
 					</span>
@@ -83,9 +90,9 @@ export function TimelineCard({
 			{item.quotedTweet ? (
 				<EmbeddedTweetCard item={item.quotedTweet} label="Quoted tweet" />
 			) : null}
-			{getVisibleUrlCards(item).map((entry) => (
+			{getVisibleUrlCards(item).map((entry, index) => (
 				<a
-					key={entry.expandedUrl}
+					key={`${entry.expandedUrl}-${String(index)}`}
 					className={linkPreviewCardClass}
 					href={entry.expandedUrl}
 					rel="noreferrer"
@@ -105,13 +112,15 @@ export function TimelineCard({
 					<span>{item.bookmarked ? "bookmarked" : "not bookmarked"}</span>
 					<span>{item.accountHandle}</span>
 				</div>
-				<button
-					className={actionButtonClass}
-					onClick={() => onReply(item.id)}
-					type="button"
-				>
-					Reply
-				</button>
+				{canReply ? (
+					<button
+						className={actionButtonClass}
+						onClick={() => onReply(item.id)}
+						type="button"
+					>
+						Reply
+					</button>
+				) : null}
 			</footer>
 		</article>
 	);

package/src/lib/archive-import.ts

@@ -25,6 +25,7 @@ interface ImportedArchiveSummary {
 	counts: {
 		tweets: number;
 		likes: number;
+		bookmarks: number;
 		dmConversations: number;
 		dmMessages: number;
 		profiles: number;
@@ -99,6 +100,10 @@ function parseTwitterDate(value: unknown) {
 		: parsed.toISOString();
 }
 
+function compareIsoTimestamp(left: string, right: string) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+
 function asRecord(value: unknown): Record<string, unknown> | null {
 	return value && typeof value === "object" && !Array.isArray(value)
 		? (value as Record<string, unknown>)
@@ -211,6 +216,39 @@ function extractTweetMedia(tweet: Record<string, unknown>) {
 		});
 }
 
+function extractCollectionTweet(
+	wrapper: ArchiveRecord,
+	key: "like" | "bookmark",
+) {
+	const entry = asRecord(wrapper[key]) ?? asRecord(wrapper.tweet);
+	if (!entry) return null;
+
+	const id = String(
+		entry.tweetId ?? entry.tweet_id ?? entry.id_str ?? entry.id ?? "",
+	);
+	if (!id) return null;
+
+	return {
+		id,
+		text: String(
+			entry.fullText ??
+				entry.full_text ??
+				entry.text ??
+				entry.expandedUrl ??
+				entry.expanded_url ??
+				"",
+		),
+		createdAt: parseTwitterDate(
+			entry.likedAt ??
+				entry.bookmarkedAt ??
+				entry.createdAt ??
+				entry.created_at ??
+				new Date(0).toISOString(),
+		),
+		likeCount: toInt(entry.favorite_count ?? entry.like_count),
+	};
+}
+
 function buildAccountPayload(
 	accountRecord: Record<string, unknown> | null,
 	profileRecord: Record<string, unknown> | null,
@@ -248,6 +286,7 @@ function clearImportedData() {
 	db.exec(`
     delete from ai_scores;
     delete from tweet_actions;
+    delete from tweet_collections;
     delete from dm_fts;
     delete from tweets_fts;
     delete from dm_messages;
@@ -276,6 +315,10 @@ export async function importArchive(
 		entries,
 		/(?:^|\/)data\/(?:like|likes)(?:-part\d+)?\.js$/i,
 	);
+	const bookmarkEntries = getMatchingEntries(
+		entries,
+		/(?:^|\/)data\/(?:bookmark|bookmarks)(?:-part\d+)?\.js$/i,
+	);
 	const dmEntries = getMatchingEntries(
 		entries,
 		/(?:^|\/)data\/direct-messages(?:-group)?(?:-part\d+)?\.js$/i,
@@ -303,16 +346,40 @@ export async function importArchive(
 	>();
 	const tweetRows: Array<{
 		id: string;
+		kind: "home" | "like" | "bookmark";
+		authorProfileId: string;
 		text: string;
 		createdAt: string;
 		isReplied: number;
 		replyToId: string | null;
 		likeCount: number;
 		mediaCount: number;
+		bookmarked: number;
+		liked: number;
 		entitiesJson: string;
 		mediaJson: string;
 		quotedTweetId: string | null;
 	}> = [];
+	const collectionRows: Array<{
+		tweetId: string;
+		kind: "likes" | "bookmarks";
+		collectedAt: string | null;
+		source: string;
+		rawJson: string;
+	}> = [];
+	const tweetRowsById = new Map<string, (typeof tweetRows)[number]>();
+
+	function addTweetRow(row: (typeof tweetRows)[number]) {
+		const existing = tweetRowsById.get(row.id);
+		if (existing) {
+			existing.bookmarked = Math.max(existing.bookmarked, row.bookmarked);
+			existing.liked = Math.max(existing.liked, row.liked);
+			if (!existing.text && row.text) existing.text = row.text;
+			return;
+		}
+		tweetRows.push(row);
+		tweetRowsById.set(row.id, row);
+	}
 
 	for (const entry of tweetEntries) {
 		const content = await readArchiveEntry(archivePath, entry);
@@ -342,8 +409,10 @@ export async function importArchive(
 				});
 			}
 
-			tweetRows.push({
+			addTweetRow({
 				id: String(tweet.id_str ?? tweet.id),
+				kind: "home",
+				authorProfileId: "profile_me",
 				text: String(tweet.full_text ?? tweet.text ?? ""),
 				createdAt: parseTwitterDate(tweet.created_at),
 				isReplied: tweet.in_reply_to_status_id_str ? 1 : 0,
@@ -352,6 +421,8 @@ export async function importArchive(
 					: null,
 				likeCount: toInt(tweet.favorite_count),
 				mediaCount: getTweetMediaCount(tweet),
+				bookmarked: 0,
+				liked: 0,
 				entitiesJson: JSON.stringify(extractTweetEntities(tweet)),
 				mediaJson: JSON.stringify(extractTweetMedia(tweet)),
 				quotedTweetId: tweet.quoted_status_id_str
@@ -367,20 +438,25 @@ export async function importArchive(
 			const noteTweet = asRecord(wrapper.noteTweet);
 			if (!noteTweet) continue;
 			const core = asRecord(noteTweet.core);
-			tweetRows.push({
+			addTweetRow({
 				id: String(noteTweet.noteTweetId ?? noteTweet.id ?? randomUUID()),
+				kind: "home",
+				authorProfileId: "profile_me",
 				text: String(core?.text ?? ""),
 				createdAt: parseTwitterDate(noteTweet.createdAt),
 				isReplied: 0,
 				replyToId: null,
 				likeCount: 0,
 				mediaCount: 0,
+				bookmarked: 0,
+				liked: 0,
 				entitiesJson: "{}",
 				mediaJson: "[]",
 				quotedTweetId: null,
 			});
 		}
 	}
+	const authoredTweetCount = tweetRows.length;
 
 	type MessageRow = {
 		id: string;
@@ -567,10 +643,8 @@ export async function importArchive(
 						mediaCount: asArray(messageCreate.mediaUrls).length,
 					} satisfies MessageRow;
 				})
-				.sort(
-					(left, right) =>
-						new Date(left.createdAt).getTime() -
-						new Date(right.createdAt).getTime(),
+				.sort((left, right) =>
+					compareIsoTimestamp(left.createdAt, right.createdAt),
 				);
 
 			if (messageEvents.length === 0) {
@@ -596,18 +670,92 @@ export async function importArchive(
 		}
 	}
 
-	const likeCount = likeEntries.reduce(async (countPromise, entry) => {
-		const count = await countPromise;
+	let likeCount = 0;
+	for (const entry of likeEntries) {
+		const content = await readArchiveEntry(archivePath, entry);
+		const likes = parseArchiveArray(content);
+		for (const like of likes) {
+			const tweet = extractCollectionTweet(like, "like");
+			if (!tweet) continue;
+			collectionRows.push({
+				tweetId: tweet.id,
+				kind: "likes",
+				collectedAt: tweet.createdAt,
+				source: "archive",
+				rawJson: JSON.stringify(like),
+			});
+			addTweetRow({
+				id: tweet.id,
+				kind: "like",
+				authorProfileId: "profile_unknown",
+				text: tweet.text,
+				createdAt: tweet.createdAt,
+				isReplied: 0,
+				replyToId: null,
+				likeCount: tweet.likeCount,
+				mediaCount: 0,
+				bookmarked: 0,
+				liked: 1,
+				entitiesJson: "{}",
+				mediaJson: "[]",
+				quotedTweetId: null,
+			});
+		}
+		likeCount += likes.length;
+	}
+
+	let bookmarkCount = 0;
+	for (const entry of bookmarkEntries) {
 		const content = await readArchiveEntry(archivePath, entry);
-		return count + parseArchiveArray(content).length;
-	}, Promise.resolve(0));
+		const bookmarks = parseArchiveArray(content);
+		for (const bookmark of bookmarks) {
+			const tweet = extractCollectionTweet(bookmark, "bookmark");
+			if (!tweet) continue;
+			collectionRows.push({
+				tweetId: tweet.id,
+				kind: "bookmarks",
+				collectedAt: tweet.createdAt,
+				source: "archive",
+				rawJson: JSON.stringify(bookmark),
+			});
+			addTweetRow({
+				id: tweet.id,
+				kind: "bookmark",
+				authorProfileId: "profile_unknown",
+				text: tweet.text,
+				createdAt: tweet.createdAt,
+				isReplied: 0,
+				replyToId: null,
+				likeCount: tweet.likeCount,
+				mediaCount: 0,
+				bookmarked: 1,
+				liked: 0,
+				entitiesJson: "{}",
+				mediaJson: "[]",
+				quotedTweetId: null,
+			});
+		}
+		bookmarkCount += bookmarks.length;
+	}
+
+	if (tweetRows.some((tweet) => tweet.authorProfileId === "profile_unknown")) {
+		profiles.set("profile_unknown", {
+			id: "profile_unknown",
+			handle: "unknown",
+			displayName: "Unknown",
+			bio: "Imported from archive collection metadata",
+			followersCount: 0,
+			avatarHue: 210,
+			createdAt: accountPayload.createdAt,
+		});
+	}
 
 	clearImportedData();
 
 	const db = getNativeDb();
 	const insertAccount = db.prepare(`
-    insert into accounts (id, name, handle, transport, is_default, created_at)
-    values (?, ?, ?, ?, 1, ?)
+    insert into accounts (id, name, handle, external_user_id, transport, is_default, created_at)
+    values (?, ?, ?, ?, ?, 1, ?)
   `);
 	const insertProfile = db.prepare(`
     insert into profiles (id, handle, display_name, bio, followers_count, avatar_hue, avatar_url, created_at)
@@ -617,11 +765,21 @@ export async function importArchive(
     insert into tweets (
       id, account_id, author_profile_id, kind, text, created_at, is_replied,
       reply_to_id, like_count, media_count, bookmarked, liked, entities_json, media_json, quoted_tweet_id
-    ) values (?, ?, ?, 'home', ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, ?)
+    ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 	const insertTweetFts = db.prepare(
 		"insert into tweets_fts (tweet_id, text) values (?, ?)",
 	);
+	const insertCollection = db.prepare(`
+    insert into tweet_collections (
+      account_id, tweet_id, kind, collected_at, source, raw_json, updated_at
+    ) values (?, ?, ?, ?, ?, ?, ?)
+    on conflict(account_id, tweet_id, kind) do update set
+      collected_at = coalesce(excluded.collected_at, tweet_collections.collected_at),
+      source = excluded.source,
+      raw_json = excluded.raw_json,
+      updated_at = excluded.updated_at
+  `);
 	const insertConversation = db.prepare(`
     insert into dm_conversations (
       id, account_id, participant_profile_id, title, last_message_at, unread_count, needs_reply
@@ -641,6 +799,7 @@ export async function importArchive(
 			"acct_primary",
 			accountPayload.displayName,
 			`@${accountPayload.username}`,
+			accountPayload.accountId,
 			"archive",
 			accountPayload.createdAt,
 		);
@@ -662,13 +821,16 @@ export async function importArchive(
 			insertTweet.run(
 				tweet.id,
 				"acct_primary",
-				"profile_me",
+				tweet.authorProfileId,
+				tweet.kind,
 				tweet.text,
 				tweet.createdAt,
 				tweet.isReplied,
 				tweet.replyToId,
 				tweet.likeCount,
 				tweet.mediaCount,
+				tweet.bookmarked,
+				tweet.liked,
 				tweet.entitiesJson,
 				tweet.mediaJson,
 				tweet.quotedTweetId,
@@ -676,6 +838,19 @@ export async function importArchive(
 			insertTweetFts.run(tweet.id, tweet.text);
 		}
 
+		const importedAt = new Date().toISOString();
+		for (const collection of collectionRows) {
+			insertCollection.run(
+				"acct_primary",
+				collection.tweetId,
+				collection.kind,
+				collection.collectedAt,
+				collection.source,
+				collection.rawJson,
+				importedAt,
+			);
+		}
+
 		for (const conversation of conversations.values()) {
 			insertConversation.run(
 				conversation.id,
@@ -712,8 +887,9 @@ export async function importArchive(
 			displayName: accountPayload.displayName,
 		},
 		counts: {
-			tweets: tweetRows.length,
-			likes: await likeCount,
+			tweets: authoredTweetCount,
+			likes: likeCount,
+			bookmarks: bookmarkCount,
 			dmConversations: conversations.size,
 			dmMessages: dmMessages.length,
 			profiles: profiles.size,
@@ -728,6 +904,7 @@ export const __test__ = {
 	asRecord,
 	asArray,
 	toInt,
+	compareIsoTimestamp,
 	getTweetMediaCount,
 	extractTweetEntities,
 	extractTweetMedia,