birdclaw 0.5.1 → 0.7.0

package/src/lib/conversation-surface.ts

@@ -1,6 +1,8 @@
 import { useCallback, useEffect, useSyncExternalStore } from "react";
 import type { ReactNode } from "react";
+import { Effect } from "effect";
 import type { EmbeddedTweet } from "#/lib/types";
+import { runEffectPromise } from "./effect-runtime";
 
 type ConversationStatus = "idle" | "loading" | "ready" | "error";
 
@@ -60,53 +62,81 @@ function getSnapshot() {
 	return snapshot;
 }
 
-async function loadConversation(tweetId: string) {
-	const current = snapshot.records.get(tweetId);
-	if (current?.status === "ready" || inFlight.has(tweetId)) {
-		return;
-	}
-
-	const loadGeneration = generation;
-	inFlight.add(tweetId);
-	updateRecord(tweetId, {
-		error: null,
-		items: current?.items ?? [],
-		status: "loading",
-	});
-
-	try {
-		const response = await fetch(
-			`/api/conversation?tweetId=${encodeURIComponent(tweetId)}`,
-		);
-		const data = (await response.json()) as {
+function fetchConversationItemsEffect(tweetId: string) {
+	return Effect.gen(function* () {
+		const response = yield* Effect.tryPromise({
+			try: () =>
+				fetch(`/api/conversation?tweetId=${encodeURIComponent(tweetId)}`),
+			catch: (error) => error,
+		});
+		const data = (yield* Effect.tryPromise({
+			try: () => response.json(),
+			catch: (error) => error,
+		})) as {
 			error?: string;
 			items?: EmbeddedTweet[];
 			ok?: boolean;
 		};
 		if (!response.ok || data.ok === false) {
-			throw new Error(data.error ?? "Conversation unavailable");
+			return yield* Effect.fail(
+				new Error(data.error ?? "Conversation unavailable"),
+			);
 		}
-		if (loadGeneration !== generation) {
-			return;
-		}
-		updateRecord(tweetId, {
-			error: null,
-			items: (data.items ?? []).filter(Boolean),
-			status: "ready",
-		});
-	} catch (error) {
-		if (loadGeneration !== generation) {
+		return (data.items ?? []).filter(Boolean);
+	});
+}
+
+export function loadConversationEffect(
+	surfaceId: string,
+	tweetId = surfaceId,
+): Effect.Effect<void, never> {
+	return Effect.gen(function* () {
+		const current = snapshot.records.get(surfaceId);
+		if (current?.status === "ready" || inFlight.has(surfaceId)) {
 			return;
 		}
-		updateRecord(tweetId, {
-			error:
-				error instanceof Error ? error.message : "Conversation unavailable",
-			items: [],
-			status: "error",
-		});
-	} finally {
-		inFlight.delete(tweetId);
-	}
+
+		const loadGeneration = generation;
+		inFlight.add(surfaceId);
+		yield* Effect.gen(function* () {
+			updateRecord(surfaceId, {
+				error: null,
+				items: current?.items ?? [],
+				status: "loading",
+			});
+
+			const result = yield* fetchConversationItemsEffect(tweetId).pipe(
+				Effect.match({
+					onFailure: (error) => ({ error, ok: false as const }),
+					onSuccess: (items) => ({ items, ok: true as const }),
+				}),
+			);
+
+			if (loadGeneration !== generation) {
+				return;
+			}
+			if (result.ok) {
+				updateRecord(surfaceId, {
+					error: null,
+					items: result.items,
+					status: "ready",
+				});
+			} else {
+				updateRecord(surfaceId, {
+					error:
+						result.error instanceof Error
+							? result.error.message
+							: "Conversation unavailable",
+					items: [],
+					status: "error",
+				});
+			}
+		}).pipe(Effect.ensuring(Effect.sync(() => inFlight.delete(surfaceId))));
+	});
+}
+
+function loadConversation(surfaceId: string, tweetId = surfaceId) {
+	return runEffectPromise(loadConversationEffect(surfaceId, tweetId));
 }
 
 export function retainConversationSurfaceScope() {
@@ -137,30 +167,31 @@ export function ConversationSurfaceScope({
 	return children;
 }
 
-export function useConversationSurface(tweetId: string) {
+export function useConversationSurface(surfaceId: string, tweetId = surfaceId) {
 	const currentSnapshot = useSyncExternalStore(
 		subscribe,
 		getSnapshot,
 		getSnapshot,
 	);
-	const record = currentSnapshot.records.get(tweetId) ?? emptyRecord;
-	const isOpen = currentSnapshot.expandedTweetId === tweetId;
+	const record = currentSnapshot.records.get(surfaceId) ?? emptyRecord;
+	const isOpen = currentSnapshot.expandedTweetId === surfaceId;
 
 	const toggle = useCallback(() => {
-		const nextExpanded = snapshot.expandedTweetId === tweetId ? null : tweetId;
+		const nextExpanded =
+			snapshot.expandedTweetId === surfaceId ? null : surfaceId;
 		setSnapshot({ ...snapshot, expandedTweetId: nextExpanded });
 		if (nextExpanded) {
-			void loadConversation(tweetId);
+			void loadConversation(surfaceId, tweetId);
 		}
-	}, [tweetId]);
+	}, [surfaceId, tweetId]);
 
 	const prefetch = useCallback(() => {
-		const current = snapshot.records.get(tweetId);
+		const current = snapshot.records.get(surfaceId);
 		if (current?.status === "ready" || current?.status === "loading") {
 			return;
 		}
-		void loadConversation(tweetId);
-	}, [tweetId]);
+		void loadConversation(surfaceId, tweetId);
+	}, [surfaceId, tweetId]);
 
 	return {
 		error: record.error,

package/src/lib/data-sources.ts

@@ -0,0 +1,219 @@
+import { Effect } from "effect";
+import { getAuthenticatedBirdAccountEffect } from "./bird";
+import { getNativeDb } from "./db";
+import { runEffectPromise } from "./effect-runtime";
+import type {
+	LiveDataSourceAccount,
+	LiveDataSourceCapability,
+	LiveDataSourcesResponse,
+	LiveDataSourceStatus,
+} from "./types";
+import {
+	getTransportStatusEffect,
+	lookupAuthenticatedOAuth2UserEffect,
+	readXurlOAuth2AccountsEffect,
+} from "./xurl";
+
+function errorMessage(error: unknown) {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function readLocalAccounts(): LiveDataSourceAccount[] {
+	const db = getNativeDb();
+	const rows = db
+		.prepare(
+			`
+      select id, handle, external_user_id, is_default
+      from accounts
+      order by is_default desc, lower(handle) asc
+      `,
+		)
+		.all() as Array<{
+		id: string;
+		handle: string;
+		external_user_id: string | null;
+		is_default: number;
+	}>;
+	return rows.map((row) => ({
+		id: row.external_user_id ?? row.id,
+		handle: row.handle,
+		username: row.handle.replace(/^@/, ""),
+		isDefault: row.is_default === 1,
+	}));
+}
+
+function getBirdclawStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
+	return Effect.try({
+		try: () => readLocalAccounts(),
+		catch: (error) => error,
+	}).pipe(
+		Effect.map((accounts) => ({
+			source: "birdclaw" as const,
+			label: "Birdclaw local",
+			works: true,
+			installed: true,
+			status: "ok" as const,
+			detail:
+				accounts.length > 0
+					? `${accounts.length.toString()} local account${accounts.length === 1 ? "" : "s"}`
+					: "local database ready; no accounts imported yet",
+			accounts,
+		})),
+		Effect.catchAll((error) =>
+			Effect.succeed({
+				source: "birdclaw" as const,
+				label: "Birdclaw local",
+				works: false,
+				installed: true,
+				status: "error" as const,
+				detail: errorMessage(error),
+				accounts: [],
+			}),
+		),
+	);
+}
+
+function getBirdStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
+	return getAuthenticatedBirdAccountEffect().pipe(
+		Effect.map((account) => ({
+			source: "bird" as const,
+			label: "bird",
+			works: true,
+			installed: true,
+			status: "ok" as const,
+			detail: `authenticated as @${account.username}`,
+			accounts: [
+				{
+					...(account.id ? { id: account.id } : {}),
+					username: account.username,
+					handle: `@${account.username}`,
+				},
+			],
+		})),
+		Effect.catchAll((error) =>
+			Effect.succeed({
+				source: "bird" as const,
+				label: "bird",
+				works: false,
+				status: "error" as const,
+				detail: errorMessage(error),
+				accounts: [],
+			}),
+		),
+	);
+}
+
+function getXurlStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
+	return Effect.gen(function* () {
+		const transport = yield* getTransportStatusEffect();
+		const oauth2Accounts = yield* readXurlOAuth2AccountsEffect();
+		const authenticated = yield* lookupAuthenticatedOAuth2UserEffect().pipe(
+			Effect.catchAll(() => Effect.succeed(null)),
+		);
+		const authenticatedAccount =
+			authenticated && typeof authenticated === "object"
+				? ({
+						...(typeof authenticated.id === "string"
+							? { id: authenticated.id }
+							: {}),
+						...(typeof authenticated.username === "string"
+							? {
+									username: authenticated.username,
+									handle: `@${authenticated.username}`,
+								}
+							: {}),
+					} satisfies LiveDataSourceAccount)
+				: undefined;
+		const accounts: LiveDataSourceAccount[] = [
+			...(authenticatedAccount ? [authenticatedAccount] : []),
+			...oauth2Accounts,
+		];
+		const deduped = accounts.filter(
+			(account, index) =>
+				accounts.findIndex(
+					(candidate) =>
+						(candidate.app ?? "") === (account.app ?? "") &&
+						(candidate.username ?? candidate.handle ?? "") ===
+							(account.username ?? account.handle ?? ""),
+				) === index,
+		);
+		const works = transport.availableTransport === "xurl";
+		return {
+			source: "xurl" as const,
+			label: "xurl",
+			works,
+			installed: transport.installed,
+			status: works ? ("ok" as const) : ("warning" as const),
+			detail: transport.statusText,
+			accounts: deduped,
+		};
+	}).pipe(
+		Effect.catchAll((error) =>
+			Effect.succeed({
+				source: "xurl" as const,
+				label: "xurl",
+				works: false,
+				status: "error" as const,
+				detail: errorMessage(error),
+				accounts: [],
+			}),
+		),
+	);
+}
+
+const capabilities: LiveDataSourceCapability[] = [
+	{
+		key: "timeline",
+		label: "Home timeline",
+		primary: "xurl",
+		fallbacks: ["bird"],
+	},
+	{
+		key: "mentions",
+		label: "Mentions",
+		primary: "xurl",
+		fallbacks: ["bird", "birdclaw"],
+		notes: "bird fallback is skipped when a since/start cursor requires xurl.",
+	},
+	{
+		key: "search",
+		label: "Fresh search",
+		primary: "bird",
+		fallbacks: ["xurl", "birdclaw"],
+		notes: "dated searches require xurl.",
+	},
+	{
+		key: "dms",
+		label: "DMs",
+		primary: "xurl",
+		fallbacks: ["bird", "birdclaw"],
+		notes: "message requests require bird.",
+	},
+	{
+		key: "follow-graph",
+		label: "Followers / following",
+		primary: "bird",
+		fallbacks: ["xurl", "birdclaw"],
+	},
+];
+
+export function getLiveDataSourcesEffect(): Effect.Effect<
+	LiveDataSourcesResponse,
+	never
+> {
+	return Effect.gen(function* () {
+		const sources = yield* Effect.all(
+			[getBirdclawStatusEffect(), getBirdStatusEffect(), getXurlStatusEffect()],
+			{ concurrency: "unbounded" },
+		);
+		return {
+			generatedAt: new Date().toISOString(),
+			sources,
+			capabilities,
+		};
+	});
+}
+
+export function getLiveDataSources(): Promise<LiveDataSourcesResponse> {
+	return runEffectPromise(getLiveDataSourcesEffect());
+}

package/src/lib/db.ts

@@ -117,7 +117,13 @@ export interface TweetCollectionsTable {
 export interface TweetAccountEdgesTable {
 	account_id: string;
 	tweet_id: string;
-	kind: "home" | "mention" | "authored" | "thread_context";
+	kind:
+		| "home"
+		| "mention"
+		| "authored"
+		| "search"
+		| "profile"
+		| "thread_context";
 	first_seen_at: string;
 	last_seen_at: string;
 	seen_count: number;
@@ -131,6 +137,7 @@ export interface DmConversationsTable {
 	account_id: string;
 	participant_profile_id: string;
 	title: string;
+	inbox_kind: "accepted" | "request";
 	last_message_at: string;
 	unread_count: number;
 	needs_reply: number;
@@ -257,6 +264,31 @@ export interface FollowEventsTable {
 	snapshot_id: string;
 }
 
+export interface GeocodedLocationsTable {
+	normalized_key: string;
+	original: string;
+	lat: number;
+	lng: number;
+	formatted: string | null;
+	country_code: string | null;
+	confidence: number | null;
+	provider: string;
+	approx_radius_m: number | null;
+	bounds_json: string;
+	components_json: string;
+	hits: number;
+	created_at: string;
+	last_used_at: string;
+}
+
+export interface GeocodedLocationsUnresolvedTable {
+	normalized_key: string;
+	original: string;
+	reason: string;
+	last_attempted_at: string;
+	ttl_until: string | null;
+}
+
 export interface BirdclawDatabase {
 	accounts: AccountsTable;
 	profiles: ProfilesTable;
@@ -280,6 +312,8 @@ export interface BirdclawDatabase {
 	follow_snapshots: FollowSnapshotsTable;
 	follow_snapshot_members: FollowSnapshotMembersTable;
 	follow_events: FollowEventsTable;
+	geocoded_locations: GeocodedLocationsTable;
+	geocoded_locations_unresolved: GeocodedLocationsUnresolvedTable;
 }
 
 let nativeDb: Database | undefined;
@@ -429,6 +463,7 @@ const BASE_SCHEMA_SQL = `
     account_id text not null,
     participant_profile_id text not null,
     title text not null,
+    inbox_kind text not null default 'accepted',
     last_message_at text not null,
     unread_count integer not null default 0,
     needs_reply integer not null default 0
@@ -561,6 +596,31 @@ const BASE_SCHEMA_SQL = `
     snapshot_id text not null
   );
 
+  create table if not exists geocoded_locations (
+    normalized_key text primary key,
+    original text not null,
+    lat real not null,
+    lng real not null,
+    formatted text,
+    country_code text,
+    confidence integer,
+    provider text not null,
+    approx_radius_m real,
+    bounds_json text not null default '{}',
+    components_json text not null default '{}',
+    hits integer not null default 1,
+    created_at text not null,
+    last_used_at text not null
+  );
+
+  create table if not exists geocoded_locations_unresolved (
+    normalized_key text primary key,
+    original text not null,
+    reason text not null,
+    last_attempted_at text not null,
+    ttl_until text
+  );
+
   create virtual table if not exists tweets_fts using fts5(
     tweet_id unindexed,
     text
@@ -609,6 +669,9 @@ const INDEX_SQL = `
   create index if not exists idx_follow_edges_profile on follow_edges(profile_id, current);
   create index if not exists idx_follow_snapshots_account on follow_snapshots(account_id, direction, completed_at desc);
   create index if not exists idx_follow_events_account on follow_events(account_id, direction, kind, event_at desc);
+  create index if not exists idx_geocoded_locations_country on geocoded_locations(country_code);
+  create index if not exists idx_geocoded_locations_last_used on geocoded_locations(last_used_at desc);
+  create index if not exists idx_geocoded_unresolved_ttl on geocoded_locations_unresolved(ttl_until desc);
 `;
 
 function getColumnNames(db: Database, tableName: string): Set<string> {
@@ -678,6 +741,15 @@ function ensureAccountExternalUserIdColumn(db: Database) {
 	}
 }
 
+function ensureDmConversationInboxColumns(db: Database) {
+	const columnNames = getColumnNames(db, "dm_conversations");
+	if (!columnNames.has("inbox_kind")) {
+		db.exec(
+			"alter table dm_conversations add column inbox_kind text not null default 'accepted'",
+		);
+	}
+}
+
 function ensureTweetCollectionsTable(db: Database) {
 	db.exec(`
     create table if not exists tweet_collections (
@@ -941,6 +1013,7 @@ function initDatabase(options: InitDatabaseOptions = {}) {
 		nativeDb = new NativeSqliteDatabase(dbPath);
 		nativeDb.exec(BASE_SCHEMA_SQL);
 		ensureAccountExternalUserIdColumn(nativeDb);
+		ensureDmConversationInboxColumns(nativeDb);
 		ensureTweetMetadataColumns(nativeDb);
 		ensureProfileAvatarColumns(nativeDb);
 		ensureTweetCollectionsTable(nativeDb);
@@ -981,11 +1054,29 @@ export function getDb() {
 	return kyselyDb as Kysely<BirdclawDatabase>;
 }
 
-export function resetDatabaseForTests() {
-	kyselyDb?.destroy();
+export async function closeDatabase() {
+	const db = kyselyDb;
+	const native = nativeDb;
 	kyselyDb = undefined;
+	nativeDb = undefined;
+	demoSeedAttempted = false;
 
-	nativeDb?.close();
+	if (db) {
+		await db.destroy();
+	} else {
+		native?.close();
+	}
+}
+
+export function resetDatabaseForTests() {
+	const db = kyselyDb;
+	const native = nativeDb;
+	kyselyDb = undefined;
 	nativeDb = undefined;
 	demoSeedAttempted = false;
+	if (db) {
+		void db.destroy();
+	} else {
+		native?.close();
+	}
 }