feat: include image alt text with post context

Dockerfile

···
 
 COPY . .
 
-ENV AUTHORIZED_USERS=""
-ENV SERVICE="https://bsky.social"
-ENV DB_PATH="data/sqlite.db"
-ENV GEMINI_MODEL="gemini-2.5-flash"
-ENV ADMIN_DID=""
-ENV ADMIN_HANDLE=""
-ENV DID=""
-ENV HANDLE=""
-ENV BSKY_PASSWORD=""
-ENV GEMINI_API_KEY=""
-
 CMD ["bun", "start"]

docker-compose.yml

···
+services:
+  aero:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    environment:
+      - "AUTHORIZED_USERS="
+      - "SERVICE=${SERVICE:?https://bsky.social}"
+      - "DB_PATH=data/sqlite.db"
+      - "GEMINI_MODEL=${GEMINI_MODEL:?gemini-2.5-flash}"
+      - "DID=${DID:?}"
+      - "HANDLE=${HANDLE:?}"
+      - "BSKY_PASSWORD=${BSKY_PASSWORD:?}"
+      - "GEMINI_API_KEY=${GEMINI_API_KEY:?}"
+    volumes:
+      - .:/app
+      - aero_db:/app/data

src/env.ts

···
   DB_PATH: z.string().default("sqlite.db"),
   GEMINI_MODEL: z.string().default("gemini-2.5-flash"),
 
-  ADMIN_DID: z.string(),
-  ADMIN_HANDLE: z.string(),
   DID: z.string(),
   HANDLE: z.string(),
   BSKY_PASSWORD: z.string(),

src/utils/conversation.ts

···
 import { and, eq } from "drizzle-orm";
 import { env } from "../env";
 import { bot, MAX_GRAPHEMES } from "../core";
-import { traverseThread } from "./thread";
+import { parsePostImages, traverseThread } from "./post";
 
+/*
+    Utilities
+*/
 const resolveDid = (convo: Conversation, did: string) =>
     convo.members.find((actor) => actor.did == did)!;
 
···
     return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 
+/*
+    Conversations
+*/
 async function initConvo(convo: Conversation) {
     const user = getUserDid(convo);
 
···
                 ? `${post.author.displayName} (${post.author.handle})`
                 : `Handle: ${post.author.handle}`,
             text: post.text,
+            images: parsePostImages(post),
             likes: post.likeCount || 0,
             replies: post.replyCount || 0,
         },
···
     });
 }
 
+/*
+    Messages
+*/
 async function parseMessagePostUri(message: ChatMessage) {
     if (!message.embed) return null;
     const post = message.embed;
···
         });
 }
 
+/*
+    Reponse Utilities
+*/
 export function exceedsGraphemes(content: string) {
     return graphemeLength(content) > MAX_GRAPHEMES;
 }

src/utils/post.ts

···
+import { EmbedImage, Post } from "@skyware/bot";
+import * as c from "../core";
+import * as yaml from "js-yaml";
+
+export function parsePostImages(post: Post) {
+  if (!post.embed) return [];
+
+  let images: EmbedImage[] = [];
+
+  if (post.embed.isImages()) {
+    images = post.embed.images;
+  } else if (post.embed.isRecordWithMedia()) {
+    const media = post.embed.media;
+    if (media && media.isImages()) {
+      images = media.images;
+    }
+  }
+
+  return images.map((image, idx) => parseImage(image, idx + 1));
+}
+
+function parseImage(image: EmbedImage, index: number) {
+  return {
+    index: index,
+    alt: image.alt,
+  };
+}
+
+/*
+  Traversal
+*/
+export async function traverseThread(post: Post): Promise<Post[]> {
+  const thread: Post[] = [
+    post,
+  ];
+  let currentPost: Post | undefined = post;
+  let parentCount = 0;
+
+  while (
+    currentPost && parentCount < c.MAX_THREAD_DEPTH
+  ) {
+    const parentPost = await currentPost.fetchParent();
+
+    if (parentPost) {
+      thread.push(parentPost);
+      currentPost = parentPost;
+    } else {
+      break;
+    }
+    parentCount++;
+  }
+
+  return thread.reverse();
+}
+
+export function parseThread(thread: Post[]) {
+  return yaml.dump({
+    uri: thread[0]!.uri,
+    posts: thread.map((post) => ({
+      author: `${post.author.displayName} (${post.author.handle})`,
+      text: post.text,
+    })),
+  });
+}

src/utils/thread.ts

···
-import { Post } from "@skyware/bot";
-import * as c from "../core";
-import * as yaml from "js-yaml";
-
-/*
-  Traversal
-*/
-export async function traverseThread(post: Post): Promise<Post[]> {
-  const thread: Post[] = [
-    post,
-  ];
-  let currentPost: Post | undefined = post;
-  let parentCount = 0;
-
-  while (
-    currentPost && parentCount < c.MAX_THREAD_DEPTH
-  ) {
-    const parentPost = await currentPost.fetchParent();
-
-    if (parentPost) {
-      thread.push(parentPost);
-      currentPost = parentPost;
-    } else {
-      break;
-    }
-    parentCount++;
-  }
-
-  return thread.reverse();
-}
-
-export function parseThread(thread: Post[]) {
-  return yaml.dump({
-    uri: thread[0]!.uri,
-    posts: thread.map((post) => ({
-      author: `${post.author.displayName} (${post.author.handle})`,
-      text: post.text,
-    })),
-  });
-}