feat: added bskyPostRef

packages/cli/src/commands/init.ts

···
 import { findConfig, generateConfigTemplate } from "../lib/config";
 import { loadCredentials } from "../lib/credentials";
 import { createAgent, createPublication } from "../lib/atproto";
-import type { FrontmatterMapping } from "../lib/types";
+import type { FrontmatterMapping, BlueskyConfig } from "../lib/types";
 
 async function fileExists(filePath: string): Promise<boolean> {
 	try {
···
 			publicationUri = uri as string;
 		}
 
+		// Bluesky posting configuration
+		const enableBluesky = await confirm({
+			message: "Enable automatic Bluesky posting when publishing?",
+			initialValue: false,
+		});
+
+		if (enableBluesky === Symbol.for("cancel")) {
+			onCancel();
+		}
+
+		let blueskyConfig: BlueskyConfig | undefined;
+		if (enableBluesky) {
+			const maxAgeDaysInput = await text({
+				message: "Maximum age (in days) for posts to be shared on Bluesky:",
+				defaultValue: "7",
+				placeholder: "7",
+				validate: (value) => {
+					const num = parseInt(value, 10);
+					if (isNaN(num) || num < 1) {
+						return "Please enter a positive number";
+					}
+				},
+			});
+
+			if (maxAgeDaysInput === Symbol.for("cancel")) {
+				onCancel();
+			}
+
+			const maxAgeDays = parseInt(maxAgeDaysInput as string, 10);
+			blueskyConfig = {
+				enabled: true,
+				...(maxAgeDays !== 7 && { maxAgeDays }),
+			};
+		}
+
 		// Get PDS URL from credentials (already loaded earlier)
 		const pdsUrl = credentials?.pdsUrl;
 
···
 			publicationUri,
 			pdsUrl,
 			frontmatter: frontmatterMapping,
+			bluesky: blueskyConfig,
 		});
 
 		const configPath = path.join(process.cwd(), "sequoia.json");

packages/cli/src/commands/publish.ts

···
 import * as path from "path";
 import { loadConfig, loadState, saveState, findConfig } from "../lib/config";
 import { loadCredentials, listCredentials, getCredentials } from "../lib/credentials";
-import { createAgent, createDocument, updateDocument, uploadImage, resolveImagePath } from "../lib/atproto";
+import { createAgent, createDocument, updateDocument, uploadImage, resolveImagePath, createBlueskyPost, addBskyPostRefToDocument } from "../lib/atproto";
 import {
   scanContentDirectory,
   getContentHash,
   updateFrontmatterWithAtUri,
 } from "../lib/markdown";
-import type { BlogPost, BlobObject } from "../lib/types";
+import type { BlogPost, BlobObject, StrongRef } from "../lib/types";
 import { exitOnCancel } from "../lib/prompts";
 
 export const publishCommand = command({
···
     }
 
     log.info(`\n${postsToPublish.length} posts to publish:\n`);
+
+    // Bluesky posting configuration
+    const blueskyEnabled = config.bluesky?.enabled ?? false;
+    const maxAgeDays = config.bluesky?.maxAgeDays ?? 7;
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+
     for (const { post, action, reason } of postsToPublish) {
       const icon = action === "create" ? "+" : "~";
-      log.message(`  ${icon} ${post.frontmatter.title} (${reason})`);
+      const relativeFilePath = path.relative(configDir, post.filePath);
+      const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;
+
+      let bskyNote = "";
+      if (blueskyEnabled) {
+        if (existingBskyPostRef) {
+          bskyNote = " [bsky: exists]";
+        } else {
+          const publishDate = new Date(post.frontmatter.publishDate);
+          if (publishDate < cutoffDate) {
+            bskyNote = ` [bsky: skipped, older than ${maxAgeDays} days]`;
+          } else {
+            bskyNote = " [bsky: will post]";
+          }
+        }
+      }
+
+      log.message(`  ${icon} ${post.frontmatter.title} (${reason})${bskyNote}`);
     }
 
     if (dryRun) {
+      if (blueskyEnabled) {
+        log.info(`\nBluesky posting: enabled (max age: ${maxAgeDays} days)`);
+      }
       log.info("\nDry run complete. No changes made.");
       return;
     }
···
     let publishedCount = 0;
     let updatedCount = 0;
     let errorCount = 0;
+    let bskyPostCount = 0;
 
     for (const { post, action } of postsToPublish) {
       s.start(`Publishing: ${post.frontmatter.title}`);
···
           }
         }
 
-        // Track atUri and content for state saving
+        // Track atUri, content for state saving, and bskyPostRef
         let atUri: string;
         let contentForHash: string;
+        let bskyPostRef: StrongRef | undefined;
+        const relativeFilePath = path.relative(configDir, post.filePath);
+
+        // Check if bskyPostRef already exists in state
+        const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;
 
         if (action === "create") {
           atUri = await createDocument(agent, post, config, coverImage);
···
           updatedCount++;
         }
 
+        // Create Bluesky post if enabled and conditions are met
+        if (blueskyEnabled) {
+          if (existingBskyPostRef) {
+            log.info(`  Bluesky post already exists, skipping`);
+            bskyPostRef = existingBskyPostRef;
+          } else {
+            const publishDate = new Date(post.frontmatter.publishDate);
+
+            if (publishDate < cutoffDate) {
+              log.info(`  Post is older than ${maxAgeDays} days, skipping Bluesky post`);
+            } else {
+              // Create Bluesky post
+              try {
+                const pathPrefix = config.pathPrefix || "/posts";
+                const canonicalUrl = `${config.siteUrl}${pathPrefix}/${post.slug}`;
+
+                bskyPostRef = await createBlueskyPost(agent, {
+                  title: post.frontmatter.title,
+                  description: post.frontmatter.description,
+                  canonicalUrl,
+                  coverImage,
+                  publishedAt: post.frontmatter.publishDate,
+                });
+
+                // Update document record with bskyPostRef
+                await addBskyPostRefToDocument(agent, atUri, bskyPostRef);
+                log.info(`  Created Bluesky post: ${bskyPostRef.uri}`);
+                bskyPostCount++;
+              } catch (bskyError) {
+                const errorMsg = bskyError instanceof Error ? bskyError.message : String(bskyError);
+                log.warn(`  Failed to create Bluesky post: ${errorMsg}`);
+              }
+            }
+          }
+        }
+
         // Update state (use relative path from config directory)
         const contentHash = await getContentHash(contentForHash);
-        const relativeFilePath = path.relative(configDir, post.filePath);
         state.posts[relativeFilePath] = {
           contentHash,
           atUri,
           lastPublished: new Date().toISOString(),
+          bskyPostRef,
         };
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
···
     log.message("\n---");
     log.info(`Published: ${publishedCount}`);
     log.info(`Updated: ${updatedCount}`);
+    if (bskyPostCount > 0) {
+      log.info(`Bluesky posts: ${bskyPostCount}`);
+    }
     if (errorCount > 0) {
       log.warn(`Errors: ${errorCount}`);
     }

packages/cli/src/lib/atproto.ts

···
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as mimeTypes from "mime-types";
-import type { Credentials, BlogPost, BlobObject, PublisherConfig } from "./types";
+import type { Credentials, BlogPost, BlobObject, PublisherConfig, StrongRef } from "./types";
 import { stripMarkdownForText } from "./markdown";
 
 async function fileExists(filePath: string): Promise<boolean> {
···
 
   return response.data.uri;
 }
+
+// --- Bluesky Post Creation ---
+
+export interface CreateBlueskyPostOptions {
+  title: string;
+  description?: string;
+  canonicalUrl: string;
+  coverImage?: BlobObject;
+  publishedAt: string; // Used as createdAt for the post
+}
+
+/**
+ * Count graphemes in a string (for Bluesky's 300 grapheme limit)
+ */
+function countGraphemes(str: string): number {
+  // Use Intl.Segmenter if available, otherwise fallback to spread operator
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+    return [...segmenter.segment(str)].length;
+  }
+  return [...str].length;
+}
+
+/**
+ * Truncate a string to a maximum number of graphemes
+ */
+function truncateToGraphemes(str: string, maxGraphemes: number): string {
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+    const segments = [...segmenter.segment(str)];
+    if (segments.length <= maxGraphemes) return str;
+    return segments.slice(0, maxGraphemes - 3).map(s => s.segment).join("") + "...";
+  }
+  // Fallback
+  const chars = [...str];
+  if (chars.length <= maxGraphemes) return str;
+  return chars.slice(0, maxGraphemes - 3).join("") + "...";
+}
+
+/**
+ * Create a Bluesky post with external link embed
+ */
+export async function createBlueskyPost(
+  agent: AtpAgent,
+  options: CreateBlueskyPostOptions
+): Promise<StrongRef> {
+  const { title, description, canonicalUrl, coverImage, publishedAt } = options;
+
+  // Build post text: title + description + URL
+  // Max 300 graphemes for Bluesky posts
+  const MAX_GRAPHEMES = 300;
+
+  let postText: string;
+  const urlPart = `\n\n${canonicalUrl}`;
+  const urlGraphemes = countGraphemes(urlPart);
+
+  if (description) {
+    // Try: title + description + URL
+    const fullText = `${title}\n\n${description}${urlPart}`;
+    if (countGraphemes(fullText) <= MAX_GRAPHEMES) {
+      postText = fullText;
+    } else {
+      // Truncate description to fit
+      const availableForDesc = MAX_GRAPHEMES - countGraphemes(title) - countGraphemes("\n\n") - urlGraphemes - countGraphemes("\n\n");
+      if (availableForDesc > 10) {
+        const truncatedDesc = truncateToGraphemes(description, availableForDesc);
+        postText = `${title}\n\n${truncatedDesc}${urlPart}`;
+      } else {
+        // Just title + URL
+        postText = `${title}${urlPart}`;
+      }
+    }
+  } else {
+    // Just title + URL
+    postText = `${title}${urlPart}`;
+  }
+
+  // Final truncation if still too long (shouldn't happen but safety check)
+  if (countGraphemes(postText) > MAX_GRAPHEMES) {
+    postText = truncateToGraphemes(postText, MAX_GRAPHEMES);
+  }
+
+  // Calculate byte indices for the URL facet
+  const encoder = new TextEncoder();
+  const urlStartInText = postText.lastIndexOf(canonicalUrl);
+  const beforeUrl = postText.substring(0, urlStartInText);
+  const byteStart = encoder.encode(beforeUrl).length;
+  const byteEnd = byteStart + encoder.encode(canonicalUrl).length;
+
+  // Build facets for the URL link
+  const facets = [
+    {
+      index: {
+        byteStart,
+        byteEnd,
+      },
+      features: [
+        {
+          $type: "app.bsky.richtext.facet#link",
+          uri: canonicalUrl,
+        },
+      ],
+    },
+  ];
+
+  // Build external embed
+  const embed: Record<string, unknown> = {
+    $type: "app.bsky.embed.external",
+    external: {
+      uri: canonicalUrl,
+      title: title.substring(0, 500), // Max 500 chars for title
+      description: (description || "").substring(0, 1000), // Max 1000 chars for description
+    },
+  };
+
+  // Add thumbnail if coverImage is available
+  if (coverImage) {
+    (embed.external as Record<string, unknown>).thumb = coverImage;
+  }
+
+  // Create the post record
+  const record: Record<string, unknown> = {
+    $type: "app.bsky.feed.post",
+    text: postText,
+    facets,
+    embed,
+    createdAt: new Date(publishedAt).toISOString(),
+  };
+
+  const response = await agent.com.atproto.repo.createRecord({
+    repo: agent.session!.did,
+    collection: "app.bsky.feed.post",
+    record,
+  });
+
+  return {
+    uri: response.data.uri,
+    cid: response.data.cid,
+  };
+}
+
+/**
+ * Add bskyPostRef to an existing document record
+ */
+export async function addBskyPostRefToDocument(
+  agent: AtpAgent,
+  documentAtUri: string,
+  bskyPostRef: StrongRef
+): Promise<void> {
+  const parsed = parseAtUri(documentAtUri);
+  if (!parsed) {
+    throw new Error(`Invalid document URI: ${documentAtUri}`);
+  }
+
+  // Fetch existing record
+  const existingRecord = await agent.com.atproto.repo.getRecord({
+    repo: parsed.did,
+    collection: parsed.collection,
+    rkey: parsed.rkey,
+  });
+
+  // Add bskyPostRef to the record
+  const updatedRecord = {
+    ...(existingRecord.data.value as Record<string, unknown>),
+    bskyPostRef,
+  };
+
+  // Update the record
+  await agent.com.atproto.repo.putRecord({
+    repo: parsed.did,
+    collection: parsed.collection,
+    rkey: parsed.rkey,
+    record: updatedRecord,
+  });
+}

packages/cli/src/lib/config.ts

···
 import * as fs from "fs/promises";
 import * as path from "path";
-import type { PublisherConfig, PublisherState, FrontmatterMapping } from "./types";
+import type { PublisherConfig, PublisherState, FrontmatterMapping, BlueskyConfig } from "./types";
 
 const CONFIG_FILENAME = "sequoia.json";
 const STATE_FILENAME = ".sequoia-state.json";
···
 	pdsUrl?: string;
 	frontmatter?: FrontmatterMapping;
 	ignore?: string[];
+	bluesky?: BlueskyConfig;
 }): string {
 	const config: Record<string, unknown> = {
 		siteUrl: options.siteUrl,
···
 
 	if (options.ignore && options.ignore.length > 0) {
 		config.ignore = options.ignore;
+	}
+
+	if (options.bluesky) {
+		config.bluesky = options.bluesky;
 	}
 
 	return JSON.stringify(config, null, 2);

packages/cli/src/lib/types.ts

···
 	tags?: string; // Field name for tags (default: "tags")
 }
 
+// Strong reference for Bluesky post (com.atproto.repo.strongRef)
+export interface StrongRef {
+	uri: string; // at:// URI format
+	cid: string; // Content ID
+}
+
+// Bluesky posting configuration
+export interface BlueskyConfig {
+	enabled: boolean;
+	maxAgeDays?: number; // Only post if published within N days (default: 7)
+}
+
 export interface PublisherConfig {
 	siteUrl: string;
 	contentDir: string;
···
 	identity?: string; // Which stored identity to use (matches identifier)
 	frontmatter?: FrontmatterMapping; // Custom frontmatter field mappings
 	ignore?: string[]; // Glob patterns for files to ignore (e.g., ["_index.md", "**/drafts/**"])
+	bluesky?: BlueskyConfig; // Optional Bluesky posting configuration
 }
 
 export interface Credentials {
···
 	contentHash: string;
 	atUri?: string;
 	lastPublished?: string;
+	bskyPostRef?: StrongRef; // Reference to corresponding Bluesky post
 }
 
 export interface PublicationRecord {