birdclaw 0.1.0

package/src/lib/mutes-write.ts

@@ -0,0 +1,118 @@
+import { runModerationAction } from "./actions-transport";
+import {
+	deleteModerationRow,
+	type ModerationActionOptions,
+	resolveModerationTarget,
+	writeModerationRow,
+} from "./moderation-write";
+
+export async function addMute(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	const { db, resolved, resolvedAccountId, actionQuery } =
+		await resolveModerationTarget({
+			accountId,
+			query,
+			selfActionError: "Cannot mute the current account",
+		});
+	const transport = await runModerationAction({
+		action: "mute",
+		query: actionQuery,
+		targetUserId: resolved.externalUserId,
+		transport: options.transport,
+	});
+
+	if (!transport.ok) {
+		return {
+			ok: false,
+			action: "mute",
+			accountId: resolvedAccountId,
+			profile: resolved.profile,
+			transport,
+		};
+	}
+
+	const mutedAt = new Date().toISOString();
+	writeModerationRow(
+		db,
+		"mutes",
+		resolvedAccountId,
+		resolved.profile.id,
+		mutedAt,
+	);
+
+	return {
+		ok: true,
+		action: "mute",
+		accountId: resolvedAccountId,
+		mutedAt,
+		profile: resolved.profile,
+		transport,
+	};
+}
+
+export async function recordMute(accountId: string, query: string) {
+	const { db, resolved, resolvedAccountId } = await resolveModerationTarget({
+		accountId,
+		query,
+		selfActionError: "Cannot mute the current account",
+	});
+
+	const mutedAt = new Date().toISOString();
+	writeModerationRow(
+		db,
+		"mutes",
+		resolvedAccountId,
+		resolved.profile.id,
+		mutedAt,
+	);
+
+	return {
+		ok: true,
+		action: "record-mute",
+		accountId: resolvedAccountId,
+		mutedAt,
+		profile: resolved.profile,
+	};
+}
+
+export async function removeMute(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	const { db, resolved, resolvedAccountId, actionQuery } =
+		await resolveModerationTarget({
+			accountId,
+			query,
+			selfActionError: "Cannot mute the current account",
+		});
+	const transport = await runModerationAction({
+		action: "unmute",
+		query: actionQuery,
+		targetUserId: resolved.externalUserId,
+		transport: options.transport,
+	});
+
+	if (!transport.ok) {
+		return {
+			ok: false,
+			action: "unmute",
+			accountId: resolvedAccountId,
+			profile: resolved.profile,
+			transport,
+		};
+	}
+
+	deleteModerationRow(db, "mutes", resolvedAccountId, resolved.profile.id);
+
+	return {
+		ok: true,
+		action: "unmute",
+		accountId: resolvedAccountId,
+		profile: resolved.profile,
+		transport,
+	};
+}

package/src/lib/mutes.ts

@@ -0,0 +1,77 @@
+import { getNativeDb } from "./db";
+import { toProfile } from "./moderation-target";
+import type { BlockItem } from "./types";
+
+export { addMute, recordMute, removeMute } from "./mutes-write";
+
+export interface MuteItem {
+	accountId: string;
+	accountHandle: string;
+	source: string;
+	mutedAt: string;
+	profile: BlockItem["profile"];
+}
+
+export function listMutes({
+	account,
+	search,
+	limit = 50,
+}: {
+	account?: string;
+	search?: string;
+	limit?: number;
+} = {}): MuteItem[] {
+	const db = getNativeDb();
+	const params: Array<string | number> = [];
+	let where = "where 1 = 1";
+
+	if (account && account !== "all") {
+		where += " and m.account_id = ?";
+		params.push(account);
+	}
+
+	if (search?.trim()) {
+		where += " and (p.handle like ? or p.display_name like ? or p.bio like ?)";
+		params.push(
+			`%${search.trim()}%`,
+			`%${search.trim()}%`,
+			`%${search.trim()}%`,
+		);
+	}
+
+	params.push(limit);
+
+	const rows = db
+		.prepare(
+			`
+      select
+        m.account_id,
+        a.handle as account_handle,
+        m.source,
+        m.created_at as muted_at,
+        p.id,
+        p.handle,
+        p.display_name,
+        p.bio,
+        p.followers_count,
+        p.avatar_hue,
+        p.avatar_url,
+        p.created_at
+      from mutes m
+      join accounts a on a.id = m.account_id
+      join profiles p on p.id = m.profile_id
+      ${where}
+      order by m.created_at desc
+      limit ?
+      `,
+		)
+		.all(...params) as Array<Record<string, unknown>>;
+
+	return rows.map((row) => ({
+		accountId: String(row.account_id),
+		accountHandle: String(row.account_handle),
+		source: String(row.source),
+		mutedAt: String(row.muted_at),
+		profile: toProfile(row),
+	}));
+}

package/src/lib/openai.ts

@@ -0,0 +1,86 @@
+export interface OpenAIInboxScore {
+	score: number;
+	summary: string;
+	reasoning: string;
+	model: string;
+}
+
+export interface OpenAIInboxInput {
+	entityKind: "mention" | "dm";
+	title: string;
+	text: string;
+	participant: {
+		handle: string;
+		displayName: string;
+		bio: string;
+		followersCount: number;
+	};
+	influenceScore: number;
+}
+
+function clampScore(value: number) {
+	return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+export async function scoreInboxItemWithOpenAI(
+	input: OpenAIInboxInput,
+): Promise<OpenAIInboxScore> {
+	const apiKey = process.env.OPENAI_API_KEY;
+	if (!apiKey) {
+		throw new Error("OPENAI_API_KEY is not set");
+	}
+
+	const model = process.env.BIRDCLAW_OPENAI_MODEL || "gpt-5.2";
+	const response = await fetch("https://api.openai.com/v1/chat/completions", {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${apiKey}`,
+			"content-type": "application/json",
+		},
+		body: JSON.stringify({
+			model,
+			response_format: { type: "json_object" },
+			messages: [
+				{
+					role: "system",
+					content:
+						"You rank inbound X mentions and DMs for Peter Steinberger. Return JSON only with keys score, summary, reasoning. Score 0-100. High score means worth replying soon. Prefer specific, actionable, novel, high-signal items. Penalize generic praise, low-context asks, and low-signal chatter. summary max 18 words. reasoning max 28 words.",
+				},
+				{
+					role: "user",
+					content: JSON.stringify(input),
+				},
+			],
+		}),
+	});
+
+	if (!response.ok) {
+		throw new Error(`OpenAI request failed: ${response.status}`);
+	}
+
+	const payload = (await response.json()) as {
+		choices?: Array<{
+			message?: {
+				content?: string;
+			};
+		}>;
+	};
+
+	const content = payload.choices?.[0]?.message?.content;
+	if (!content) {
+		throw new Error("OpenAI returned no content");
+	}
+
+	const parsed = JSON.parse(content) as {
+		score?: number;
+		summary?: string;
+		reasoning?: string;
+	};
+
+	return {
+		model,
+		score: clampScore(parsed.score ?? 0),
+		summary: String(parsed.summary ?? "No summary"),
+		reasoning: String(parsed.reasoning ?? "No reasoning"),
+	};
+}

package/src/lib/present.ts

@@ -0,0 +1,20 @@
+export function formatCompactNumber(value: number) {
+	return new Intl.NumberFormat("en", { notation: "compact" }).format(value);
+}
+
+export function formatShortTimestamp(value: string) {
+	return new Intl.DateTimeFormat("en", {
+		hour: "numeric",
+		minute: "2-digit",
+		month: "short",
+		day: "numeric",
+	}).format(new Date(value));
+}
+
+export function getInitials(value: string) {
+	return value
+		.split(" ")
+		.map((part) => part[0] ?? "")
+		.join("")
+		.slice(0, 2);
+}

package/src/lib/profile-hydration.ts

@@ -0,0 +1,144 @@
+import { normalizeAvatarUrl } from "./avatar-cache";
+import { getNativeDb } from "./db";
+import {
+	getTransportStatus,
+	lookupAuthenticatedUser,
+	lookupUsersByIds,
+} from "./xurl";
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function toInt(value: unknown) {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? Math.trunc(parsed) : 0;
+}
+
+export async function hydrateProfilesFromX() {
+	const transport = await getTransportStatus();
+	if (transport.availableTransport !== "xurl") {
+		return {
+			ok: true,
+			hydratedProfiles: 0,
+			hydratedAccount: false,
+			reason: transport.statusText,
+		};
+	}
+
+	const db = getNativeDb();
+	const candidateRows = db
+		.prepare(
+			`
+      select id
+      from profiles
+      where id like 'profile_user_%'
+        and (followers_count = 0 or bio like 'Imported from archive user %' or handle like 'id%')
+      order by id asc
+      `,
+		)
+		.all() as Array<{ id: string }>;
+
+	const candidateIds = candidateRows
+		.map((row) => row.id.replace(/^profile_user_/, ""))
+		.filter((id) => id.length > 0);
+
+	const updateProfile = db.prepare(`
+    update profiles
+    set handle = ?,
+        display_name = ?,
+        bio = ?,
+        followers_count = ?,
+        avatar_url = coalesce(?, avatar_url),
+        created_at = coalesce(?, created_at)
+    where id = ?
+  `);
+	const updateConversationTitle = db.prepare(`
+    update dm_conversations
+    set title = ?
+    where participant_profile_id = ?
+  `);
+	const updateLocalProfile = db.prepare(`
+    update profiles
+    set handle = ?,
+        display_name = ?,
+        bio = ?,
+        followers_count = ?,
+        avatar_url = coalesce(?, avatar_url),
+        created_at = coalesce(?, created_at)
+    where id = 'profile_me'
+  `);
+	const updateAccount = db.prepare(`
+    update accounts
+    set name = ?,
+        handle = ?,
+        transport = 'xurl'
+    where id = 'acct_primary'
+  `);
+
+	let hydratedProfiles = 0;
+
+	for (let index = 0; index < candidateIds.length; index += 100) {
+		const batch = candidateIds.slice(index, index + 100);
+		const users = await lookupUsersByIds(batch);
+
+		db.transaction(() => {
+			for (const user of users) {
+				const metrics = asRecord(user.public_metrics);
+				const profileId = `profile_user_${String(user.id ?? "")}`;
+				if (profileId === "profile_user_") continue;
+
+				const username = String(user.username ?? "").replace(/^@/, "");
+				const displayName = String(user.name ?? username);
+				updateProfile.run(
+					username || profileId,
+					displayName || username || profileId,
+					String(user.description ?? ""),
+					toInt(metrics?.followers_count),
+					normalizeAvatarUrl(user.profile_image_url),
+					typeof user.created_at === "string" ? user.created_at : null,
+					profileId,
+				);
+				updateConversationTitle.run(
+					displayName || username || profileId,
+					profileId,
+				);
+				hydratedProfiles += 1;
+			}
+		})();
+	}
+
+	let hydratedAccount = false;
+	const me = await lookupAuthenticatedUser().catch(() => null);
+	if (me) {
+		const metrics = asRecord(me.public_metrics);
+		db.transaction(() => {
+			updateLocalProfile.run(
+				String(me.username ?? "steipete").replace(/^@/, ""),
+				String(me.name ?? "Peter Steinberger"),
+				String(me.description ?? ""),
+				toInt(metrics?.followers_count),
+				normalizeAvatarUrl(me.profile_image_url),
+				typeof me.created_at === "string" ? me.created_at : null,
+			);
+			updateAccount.run(
+				String(me.name ?? "Peter Steinberger"),
+				`@${String(me.username ?? "steipete").replace(/^@/, "")}`,
+			);
+		})();
+		hydratedAccount = true;
+	}
+
+	return {
+		ok: true,
+		hydratedProfiles,
+		hydratedAccount,
+	};
+}
+
+export const __test__ = {
+	asRecord,
+	toInt,
+};

package/src/lib/profile-replies.ts

@@ -0,0 +1,60 @@
+import { resolveProfile } from "./moderation-target";
+import type { ProfileRepliesResponse, XurlReferencedTweet } from "./types";
+import { listUserTweets } from "./xurl";
+
+function getReplyTargetId(references?: XurlReferencedTweet[]) {
+	return references?.find((item) => item.type === "replied_to")?.id;
+}
+
+function getScanSize(limit: number) {
+	return Math.min(Math.max(limit * 3, 20), 100);
+}
+
+export async function inspectProfileReplies(
+	query: string,
+	{ limit = 12 }: { limit?: number } = {},
+): Promise<ProfileRepliesResponse> {
+	const resolved = await resolveProfile(query);
+	if (!resolved.externalUserId) {
+		throw new Error(`Profile has no external X user id: ${query}`);
+	}
+
+	const timeline = await listUserTweets(resolved.externalUserId, {
+		maxResults: getScanSize(limit),
+		excludeRetweets: true,
+	});
+	const items = timeline.items
+		.map((tweet) => {
+			const replyToTweetId = getReplyTargetId(tweet.referenced_tweets);
+			if (!replyToTweetId) {
+				return null;
+			}
+
+			return {
+				id: tweet.id,
+				text: tweet.text,
+				createdAt: tweet.created_at,
+				conversationId: tweet.conversation_id,
+				replyToTweetId,
+				likeCount: Number(tweet.public_metrics?.like_count ?? 0),
+				replyCount: Number(tweet.public_metrics?.reply_count ?? 0),
+				retweetCount: Number(tweet.public_metrics?.retweet_count ?? 0),
+				quoteCount: Number(tweet.public_metrics?.quote_count ?? 0),
+				bookmarkCount: Number(tweet.public_metrics?.bookmark_count ?? 0),
+				impressionCount: Number(tweet.public_metrics?.impression_count ?? 0),
+			};
+		})
+		.filter((item): item is NonNullable<typeof item> => item !== null)
+		.slice(0, limit);
+
+	return {
+		profile: resolved.profile,
+		externalUserId: resolved.externalUserId,
+		items,
+		meta: {
+			scannedCount: timeline.items.length,
+			returnedCount: items.length,
+			nextToken: timeline.nextToken,
+		},
+	};
+}