feat: add deletion

packages/cli/src/commands/init.ts

···
 import { createAgent, createPublication } from "../lib/atproto";
 import { selectCredential } from "../lib/credential-select";
 import type { FrontmatterMapping, BlueskyConfig } from "../lib/types";
-
-async function fileExists(filePath: string): Promise<boolean> {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
+import { fileExists } from "../lib/utils";
 
 const onCancel = () => {
 	outro("Setup cancelled");

packages/cli/src/commands/publish.ts

···
 	resolveImagePath,
 	createBlueskyPost,
 	addBskyPostRefToDocument,
+	deleteRecord,
 } from "../lib/atproto";
 import {
 	scanContentDirectory,
···
 } from "../lib/markdown";
 import type { BlogPost, BlobObject, StrongRef } from "../lib/types";
 import { exitOnCancel } from "../lib/prompts";
-import { createNote, updateNote, findPostsWithStaleLinks, type NoteOptions } from "../extensions/remanso"
+import {
+	createNote,
+	updateNote,
+	deleteNote,
+	findPostsWithStaleLinks,
+	type NoteOptions,
+} from "../extensions/remanso";
+import { fileExists } from "../lib/utils";
 
 export const publishCommand = command({
 	name: "publish",
···
 		});
 		s.stop(`Found ${posts.length} posts`);
 
+		// Detect deleted files: state entries whose local files no longer exist
+		const scannedPaths = new Set(
+			posts.map((p) => path.relative(configDir, p.filePath)),
+		);
+		const deletedEntries: Array<{ filePath: string; atUri: string }> = [];
+		for (const [filePath, postState] of Object.entries(state.posts)) {
+			if (!scannedPaths.has(filePath) && postState.atUri) {
+				// Check if the file truly doesn't exist (not just excluded by ignore patterns)
+				const absolutePath = path.resolve(configDir, filePath);
+
+				// If file exists but wasn't scanned (e.g. draft or ignored) — skip
+				if (!(await fileExists(absolutePath))) {
+					deletedEntries.push({ filePath, atUri: postState.atUri });
+				}
+			}
+		}
+
+		// Shared agent — created lazily, reused across deletion and publishing
+		let agent: Awaited<ReturnType<typeof createAgent>> | undefined;
+		async function getAgent(): Promise<
+			Awaited<ReturnType<typeof createAgent>>
+		> {
+			if (agent) return agent;
+
+			if (!credentials) {
+				throw new Error("credentials not found");
+			}
+
+			const connectingTo =
+				credentials.type === "oauth" ? credentials.handle : credentials.pdsUrl;
+			s.start(`Connecting as ${connectingTo}...`);
+			try {
+				agent = await createAgent(credentials);
+				s.stop(`Logged in as ${agent.did}`);
+				return agent;
+			} catch (error) {
+				s.stop("Failed to login");
+				log.error(`Failed to login: ${error}`);
+				process.exit(1);
+			}
+		}
+
 		// Determine which posts need publishing
 		const postsToPublish: Array<{
 			post: BlogPost;
···
 			return;
 		}
 
-		// Create agent
-		const connectingTo =
-			credentials.type === "oauth" ? credentials.handle : credentials.pdsUrl;
-		s.start(`Connecting as ${connectingTo}...`);
-		let agent: Awaited<ReturnType<typeof createAgent>> | undefined;
-		try {
-			agent = await createAgent(credentials);
-			s.stop(`Logged in as ${agent.did}`);
-		} catch (error) {
-			s.stop("Failed to login");
-			log.error(`Failed to login: ${error}`);
-			process.exit(1);
+		// Ensure agent is connected
+		await getAgent();
+
+		if (!agent) {
+			throw new Error("agent is not connected");
 		}
 
 		// Publish posts
···
 		}> = [];
 
 		for (const { post, action } of postsToPublish) {
-      const trimmedContent = post.content.trim()
-      const titleMatch = trimmedContent.match(/^# (.+)$/m)
-      const title = titleMatch ? titleMatch[1] : post.frontmatter.title
-      s.start(`Publishing: ${title}`);
+			const trimmedContent = post.content.trim();
+			const titleMatch = trimmedContent.match(/^# (.+)$/m);
+			const title = titleMatch ? titleMatch[1] : post.frontmatter.title;
+			s.start(`Publishing: ${title}`);
 
-      // Init publish date
-      if (!post.frontmatter.publishDate) {
-        const [publishDate] = new Date().toISOString().split("T")
-        post.frontmatter.publishDate = publishDate!
-      }
+			// Init publish date
+			if (!post.frontmatter.publishDate) {
+				const [publishDate] = new Date().toISOString().split("T");
+				post.frontmatter.publishDate = publishDate!;
+			}
 
 			try {
 				// Handle cover image upload
···
 
 		// Summary
 		log.message("\n---");
+		if (deletedEntries.length > 0) {
+			log.info(`Deleted: ${deletedEntries.length}`);
+		}
 		log.info(`Published: ${publishedCount}`);
 		log.info(`Updated: ${updatedCount}`);
 		if (bskyPostCount > 0) {

packages/cli/src/components/sequoia-comments.js

···
 		this.commentsContainer = container;
 		this.state = { type: "loading" };
 		this.abortController = null;
-
 	}
 
 	static get observedAttributes() {
···
 					</div>
 				`;
 				if (this.hide) {
-					this.commentsContainer.style.display = 'none';
+					this.commentsContainer.style.display = "none";
 				}
 				break;
 

packages/cli/src/extensions/remanso.test.ts

···
 
 	test("rewrites published link to remanso atUri", () => {
 		const posts = [
-			makePost(
-				"other-post",
-				"at://did:plc:abc/site.standard.document/abc123",
-			),
+			makePost("other-post", "at://did:plc:abc/site.standard.document/abc123"),
 		];
 		const content = "See [my post](./other-post)";
 		expect(resolveInternalLinks(content, posts)).toBe(
···
 
 	test("handles .md extension in link path", () => {
 		const posts = [
-			makePost(
-				"guide",
-				"at://did:plc:abc/site.standard.document/guide123",
-			),
+			makePost("guide", "at://did:plc:abc/site.standard.document/guide123"),
 		];
 		const content = "Read the [guide](guide.md)";
 		expect(resolveInternalLinks(content, posts)).toBe(
···
 
 	test("handles nested slug matching", () => {
 		const posts = [
-			makePost(
-				"blog/my-post",
-				"at://did:plc:abc/site.standard.document/rkey1",
-			),
+			makePost("blog/my-post", "at://did:plc:abc/site.standard.document/rkey1"),
 		];
 		const content = "See [post](my-post)";
 		expect(resolveInternalLinks(content, posts)).toBe(
···
 
 	test("does not rewrite image embeds", () => {
 		const posts = [
-			makePost(
-				"photo",
-				"at://did:plc:abc/site.standard.document/photo1",
-			),
+			makePost("photo", "at://did:plc:abc/site.standard.document/photo1"),
 		];
 		const content = "![alt](photo)";
 		expect(resolveInternalLinks(content, posts)).toBe("![alt](photo)");
···
 
 	test("does not rewrite @mention links", () => {
 		const posts = [
-			makePost(
-				"mention",
-				"at://did:plc:abc/site.standard.document/m1",
-			),
+			makePost("mention", "at://did:plc:abc/site.standard.document/m1"),
 		];
 		const content = "@[name](mention)";
 		expect(resolveInternalLinks(content, posts)).toBe("@[name](mention)");
···
 
 	test("handles multiple links in same content", () => {
 		const posts = [
-			makePost(
-				"published",
-				"at://did:plc:abc/site.standard.document/pub1",
-			),
+			makePost("published", "at://did:plc:abc/site.standard.document/pub1"),
 			makePost("unpublished"),
 		];
 		const content =
···
 
 	test("handles index path normalization", () => {
 		const posts = [
-			makePost(
-				"docs",
-				"at://did:plc:abc/site.standard.document/docs1",
-			),
+			makePost("docs", "at://did:plc:abc/site.standard.document/docs1"),
 		];
 		const content = "See [docs](./docs/index)";
 		expect(resolveInternalLinks(content, posts)).toBe(
···
 				content: "Check out [post](my-post)",
 			}),
 		];
-		const result = findPostsWithStaleLinks(
-			posts,
-			["blog/my-post"],
-			new Set(),
-		);
+		const result = findPostsWithStaleLinks(posts, ["blog/my-post"], new Set());
 		expect(result).toHaveLength(1);
 	});
 

packages/cli/src/extensions/remanso.ts

···
-import type { Agent } from "@atproto/api"
-import * as fs from "node:fs/promises"
-import * as path from "node:path"
-import mimeTypes from "mime-types"
-import type { BlogPost, BlobObject } from "../lib/types"
+import type { Agent } from "@atproto/api";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import mimeTypes from "mime-types";
+import type { BlogPost, BlobObject } from "../lib/types";
 
-const LEXICON = "space.remanso.note"
-const MAX_CONTENT = 10000
+const LEXICON = "space.remanso.note";
+const MAX_CONTENT = 10000;
 
 interface ImageRecord {
-  image: BlobObject
-  alt?: string
+	image: BlobObject;
+	alt?: string;
 }
 
 export interface NoteOptions {
-  contentDir: string
-  imagesDir?: string
-  allPosts: BlogPost[]
+	contentDir: string;
+	imagesDir?: string;
+	allPosts: BlogPost[];
 }
 
 async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch {
-    return false
-  }
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
 }
 
 export function isLocalPath(url: string): boolean {
-  return (
-    !url.startsWith("http://") &&
-    !url.startsWith("https://") &&
-    !url.startsWith("#") &&
-    !url.startsWith("mailto:")
-  )
+	return (
+		!url.startsWith("http://") &&
+		!url.startsWith("https://") &&
+		!url.startsWith("#") &&
+		!url.startsWith("mailto:")
+	);
 }
 
 function getImageCandidates(
-  src: string,
-  postFilePath: string,
-  contentDir: string,
-  imagesDir?: string,
+	src: string,
+	postFilePath: string,
+	contentDir: string,
+	imagesDir?: string,
 ): string[] {
-  const candidates = [
-    path.resolve(path.dirname(postFilePath), src),
-    path.resolve(contentDir, src),
-  ]
-  if (imagesDir) {
-    candidates.push(path.resolve(imagesDir, src))
-    const baseName = path.basename(imagesDir)
-    const idx = src.indexOf(baseName)
-    if (idx !== -1) {
-      const after = src.substring(idx + baseName.length).replace(/^[/\\]/, "")
-      candidates.push(path.resolve(imagesDir, after))
-    }
-  }
-  return candidates
+	const candidates = [
+		path.resolve(path.dirname(postFilePath), src),
+		path.resolve(contentDir, src),
+	];
+	if (imagesDir) {
+		candidates.push(path.resolve(imagesDir, src));
+		const baseName = path.basename(imagesDir);
+		const idx = src.indexOf(baseName);
+		if (idx !== -1) {
+			const after = src.substring(idx + baseName.length).replace(/^[/\\]/, "");
+			candidates.push(path.resolve(imagesDir, after));
+		}
+	}
+	return candidates;
 }
 
 async function uploadBlob(
-  agent: Agent,
-  candidates: string[],
+	agent: Agent,
+	candidates: string[],
 ): Promise<BlobObject | undefined> {
-  for (const filePath of candidates) {
-    if (!(await fileExists(filePath))) continue
+	for (const filePath of candidates) {
+		if (!(await fileExists(filePath))) continue;
 
-    try {
-      const imageBuffer = await fs.readFile(filePath)
-      if (imageBuffer.byteLength === 0) continue
-      const mimeType = mimeTypes.lookup(filePath) || "application/octet-stream"
-      const response = await agent.com.atproto.repo.uploadBlob(
-        new Uint8Array(imageBuffer),
-        { encoding: mimeType },
-      )
-      return {
-        $type: "blob",
-        ref: { $link: response.data.blob.ref.toString() },
-        mimeType,
-        size: imageBuffer.byteLength,
-      }
-    } catch {}
-  }
-  return undefined
+		try {
+			const imageBuffer = await fs.readFile(filePath);
+			if (imageBuffer.byteLength === 0) continue;
+			const mimeType = mimeTypes.lookup(filePath) || "application/octet-stream";
+			const response = await agent.com.atproto.repo.uploadBlob(
+				new Uint8Array(imageBuffer),
+				{ encoding: mimeType },
+			);
+			return {
+				$type: "blob",
+				ref: { $link: response.data.blob.ref.toString() },
+				mimeType,
+				size: imageBuffer.byteLength,
+			};
+		} catch {}
+	}
+	return undefined;
 }
 
 async function processImages(
-  agent: Agent,
-  content: string,
-  postFilePath: string,
-  contentDir: string,
-  imagesDir?: string,
+	agent: Agent,
+	content: string,
+	postFilePath: string,
+	contentDir: string,
+	imagesDir?: string,
 ): Promise<{ content: string; images: ImageRecord[] }> {
-  const images: ImageRecord[] = []
-  const uploadCache = new Map<string, BlobObject>()
-  let processedContent = content
+	const images: ImageRecord[] = [];
+	const uploadCache = new Map<string, BlobObject>();
+	let processedContent = content;
 
-  const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g
-  const matches = [...content.matchAll(imageRegex)]
+	const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+	const matches = [...content.matchAll(imageRegex)];
 
-  for (const match of matches) {
-    const fullMatch = match[0]
-    const alt = match[1] ?? ""
-    const src = match[2]!
-    if (!isLocalPath(src)) continue
+	for (const match of matches) {
+		const fullMatch = match[0];
+		const alt = match[1] ?? "";
+		const src = match[2]!;
+		if (!isLocalPath(src)) continue;
 
-    let blob = uploadCache.get(src)
-    if (!blob) {
-      const candidates = getImageCandidates(src, postFilePath, contentDir, imagesDir)
-      blob = await uploadBlob(agent, candidates)
-      if (!blob) continue
-      uploadCache.set(src, blob)
-    }
+		let blob = uploadCache.get(src);
+		if (!blob) {
+			const candidates = getImageCandidates(
+				src,
+				postFilePath,
+				contentDir,
+				imagesDir,
+			);
+			blob = await uploadBlob(agent, candidates);
+			if (!blob) continue;
+			uploadCache.set(src, blob);
+		}
 
-    images.push({ image: blob, alt: alt || undefined })
-    processedContent = processedContent.replace(
-      fullMatch,
-      `![${alt}](${blob.ref.$link})`,
-    )
-  }
+		images.push({ image: blob, alt: alt || undefined });
+		processedContent = processedContent.replace(
+			fullMatch,
+			`![${alt}](${blob.ref.$link})`,
+		);
+	}
 
-  return { content: processedContent, images }
+	return { content: processedContent, images };
 }
 
 export function resolveInternalLinks(
-  content: string,
-  allPosts: BlogPost[],
+	content: string,
+	allPosts: BlogPost[],
 ): string {
-  const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g
+	const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g;
 
-  return content.replace(linkRegex, (fullMatch, text, url) => {
-    if (!isLocalPath(url)) return fullMatch
+	return content.replace(linkRegex, (fullMatch, text, url) => {
+		if (!isLocalPath(url)) return fullMatch;
 
-    // Normalize to a slug-like string for comparison
-    const normalized = url
-      .replace(/^\.?\/?/, "")
-      .replace(/\/?$/, "")
-      .replace(/\.mdx?$/, "")
-      .replace(/\/index$/, "")
+		// Normalize to a slug-like string for comparison
+		const normalized = url
+			.replace(/^\.?\/?/, "")
+			.replace(/\/?$/, "")
+			.replace(/\.mdx?$/, "")
+			.replace(/\/index$/, "");
 
-    const matchedPost = allPosts.find((p) => {
-      if (!p.frontmatter.atUri) return false
-      return (
-        p.slug === normalized ||
-        p.slug.endsWith(`/${normalized}`) ||
-        normalized.endsWith(`/${p.slug}`)
-      )
-    })
+		const matchedPost = allPosts.find((p) => {
+			if (!p.frontmatter.atUri) return false;
+			return (
+				p.slug === normalized ||
+				p.slug.endsWith(`/${normalized}`) ||
+				normalized.endsWith(`/${p.slug}`)
+			);
+		});
 
-    if (!matchedPost) return text
+		if (!matchedPost) return text;
 
-    const noteUri = matchedPost.frontmatter.atUri!.replace(
-      /\/[^/]+\/([^/]+)$/,
-      `/space.remanso.note/$1`,
-    )
-    return `[${text}](${noteUri})`
-  })
+		const noteUri = matchedPost.frontmatter.atUri!.replace(
+			/\/[^/]+\/([^/]+)$/,
+			`/space.remanso.note/$1`,
+		);
+		return `[${text}](${noteUri})`;
+	});
 }
 
 async function processNoteContent(
-  agent: Agent,
-  post: BlogPost,
-  options: NoteOptions,
+	agent: Agent,
+	post: BlogPost,
+	options: NoteOptions,
 ): Promise<{ content: string; images: ImageRecord[] }> {
-  let content = post.content.trim()
+	let content = post.content.trim();
 
-  content = resolveInternalLinks(content, options.allPosts)
+	content = resolveInternalLinks(content, options.allPosts);
 
-  const result = await processImages(
-    agent, content, post.filePath, options.contentDir, options.imagesDir,
-  )
+	const result = await processImages(
+		agent,
+		content,
+		post.filePath,
+		options.contentDir,
+		options.imagesDir,
+	);
 
-  return result
+	return result;
 }
 
 function parseRkey(atUri: string): string {
-  const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/)
-  if (!uriMatch) {
-    throw new Error(`Invalid atUri format: ${atUri}`)
-  }
-  return uriMatch[3]!
+	const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
+	if (!uriMatch) {
+		throw new Error(`Invalid atUri format: ${atUri}`);
+	}
+	return uriMatch[3]!;
 }
 
 async function buildNoteRecord(
-  agent: Agent,
-  post: BlogPost,
-  options: NoteOptions,
+	agent: Agent,
+	post: BlogPost,
+	options: NoteOptions,
 ): Promise<Record<string, unknown>> {
-  const publishDate = new Date(post.frontmatter.publishDate).toISOString()
-  const trimmedContent = post.content.trim()
-  const titleMatch = trimmedContent.match(/^# (.+)$/m)
-  const title = titleMatch ? titleMatch[1] : post.frontmatter.title
+	const publishDate = new Date(post.frontmatter.publishDate).toISOString();
+	const trimmedContent = post.content.trim();
+	const titleMatch = trimmedContent.match(/^# (.+)$/m);
+	const title = titleMatch ? titleMatch[1] : post.frontmatter.title;
 
-  const { content, images } = await processNoteContent(agent, post, options)
+	const { content, images } = await processNoteContent(agent, post, options);
 
-  const record: Record<string, unknown> = {
-    $type: LEXICON,
-    title,
-    content: content.slice(0, MAX_CONTENT),
-    createdAt: publishDate,
-    publishedAt: publishDate,
-  }
+	const record: Record<string, unknown> = {
+		$type: LEXICON,
+		title,
+		content: content.slice(0, MAX_CONTENT),
+		createdAt: publishDate,
+		publishedAt: publishDate,
+	};
 
-  if (images.length > 0) {
-    record.images = images
-  }
+	if (images.length > 0) {
+		record.images = images;
+	}
 
-  if (post.frontmatter.theme) {
-    record.theme = post.frontmatter.theme
-  }
+	if (post.frontmatter.theme) {
+		record.theme = post.frontmatter.theme;
+	}
 
-  if (post.frontmatter.fontSize) {
-    record.fontSize = post.frontmatter.fontSize
-  }
+	if (post.frontmatter.fontSize) {
+		record.fontSize = post.frontmatter.fontSize;
+	}
 
-  if (post.frontmatter.fontFamily) {
-    record.fontFamily = post.frontmatter.fontFamily
-  }
+	if (post.frontmatter.fontFamily) {
+		record.fontFamily = post.frontmatter.fontFamily;
+	}
 
-  return record
+	return record;
+}
+
+export async function deleteNote(agent: Agent, atUri: string): Promise<void> {
+	const rkey = parseRkey(atUri);
+	await agent.com.atproto.repo.deleteRecord({
+		repo: agent.did!,
+		collection: LEXICON,
+		rkey,
+	});
 }
 
 export async function createNote(
-  agent: Agent,
-  post: BlogPost,
-  atUri: string,
-  options: NoteOptions,
+	agent: Agent,
+	post: BlogPost,
+	atUri: string,
+	options: NoteOptions,
 ): Promise<void> {
-  const rkey = parseRkey(atUri)
-  const record = await buildNoteRecord(agent, post, options)
+	const rkey = parseRkey(atUri);
+	const record = await buildNoteRecord(agent, post, options);
 
-  await agent.com.atproto.repo.createRecord({
-    repo: agent.did!,
-    collection: LEXICON,
-    record,
-    rkey,
-    validate: false,
-  })
+	await agent.com.atproto.repo.createRecord({
+		repo: agent.did!,
+		collection: LEXICON,
+		record,
+		rkey,
+		validate: false,
+	});
 }
 
 export async function updateNote(
-  agent: Agent,
-  post: BlogPost,
-  atUri: string,
-  options: NoteOptions,
+	agent: Agent,
+	post: BlogPost,
+	atUri: string,
+	options: NoteOptions,
 ): Promise<void> {
-  const rkey = parseRkey(atUri)
-  const record = await buildNoteRecord(agent, post, options)
+	const rkey = parseRkey(atUri);
+	const record = await buildNoteRecord(agent, post, options);
 
-  await agent.com.atproto.repo.putRecord({
-    repo: agent.did!,
-    collection: LEXICON,
-    rkey: rkey!,
-    record,
-    validate: false,
-  })
+	await agent.com.atproto.repo.putRecord({
+		repo: agent.did!,
+		collection: LEXICON,
+		rkey: rkey!,
+		record,
+		validate: false,
+	});
 }
 
 export function findPostsWithStaleLinks(
-  allPosts: BlogPost[],
-  newSlugs: string[],
-  excludeFilePaths: Set<string>,
+	allPosts: BlogPost[],
+	newSlugs: string[],
+	excludeFilePaths: Set<string>,
 ): BlogPost[] {
-  const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g
+	const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g;
 
-  return allPosts.filter((post) => {
-    if (excludeFilePaths.has(post.filePath)) return false
-    if (!post.frontmatter.atUri) return false
-    if (post.frontmatter.draft) return false
+	return allPosts.filter((post) => {
+		if (excludeFilePaths.has(post.filePath)) return false;
+		if (!post.frontmatter.atUri) return false;
+		if (post.frontmatter.draft) return false;
 
-    const matches = [...post.content.matchAll(linkRegex)]
-    return matches.some((match) => {
-      const url = match[2]!
-      if (!isLocalPath(url)) return false
+		const matches = [...post.content.matchAll(linkRegex)];
+		return matches.some((match) => {
+			const url = match[2]!;
+			if (!isLocalPath(url)) return false;
 
-      const normalized = url
-        .replace(/^\.?\/?/, "")
-        .replace(/\/?$/, "")
-        .replace(/\.mdx?$/, "")
-        .replace(/\/index$/, "")
+			const normalized = url
+				.replace(/^\.?\/?/, "")
+				.replace(/\/?$/, "")
+				.replace(/\.mdx?$/, "")
+				.replace(/\/index$/, "");
 
-      return newSlugs.some(
-        (slug) =>
-          slug === normalized ||
-          slug.endsWith(`/${normalized}`) ||
-          normalized.endsWith(`/${slug}`),
-      )
-    })
-  })
+			return newSlugs.some(
+				(slug) =>
+					slug === normalized ||
+					slug.endsWith(`/${normalized}`) ||
+					normalized.endsWith(`/${slug}`),
+			);
+		});
+	});
 }

packages/cli/src/lib/atproto.ts

···
 	const pathPrefix = config.pathPrefix || "/posts";
 	const postPath = `${pathPrefix}/${post.slug}`;
 	const publishDate = new Date(post.frontmatter.publishDate);
-  const trimmedContent = post.content.trim()
+	const trimmedContent = post.content.trim();
 	const textContent = getTextContent(post, config.textContentField);
-  const titleMatch = trimmedContent.match(/^# (.+)$/m)
-  const title = titleMatch ? titleMatch[1] : post.frontmatter.title
+	const titleMatch = trimmedContent.match(/^# (.+)$/m);
+	const title = titleMatch ? titleMatch[1] : post.frontmatter.title;
 
 	const record: Record<string, unknown> = {
 		$type: "site.standard.document",
···
 
 	const pathPrefix = config.pathPrefix || "/posts";
 	const postPath = `${pathPrefix}/${post.slug}`;
-  
+
 	const publishDate = new Date(post.frontmatter.publishDate);
-  const trimmedContent = post.content.trim()
+	const trimmedContent = post.content.trim();
 	const textContent = getTextContent(post, config.textContentField);
-  const titleMatch = trimmedContent.match(/^# (.+)$/m)
-  const title = titleMatch ? titleMatch[1] : post.frontmatter.title
+	const titleMatch = trimmedContent.match(/^# (.+)$/m);
+	const title = titleMatch ? titleMatch[1] : post.frontmatter.title;
 
 	const record: Record<string, unknown> = {
 		$type: "site.standard.document",
···
 			limit: 100,
 			cursor,
 		});
-    
+
 		for (const record of response.data.records) {
-      if (!isDocumentRecord(record.value)) {
+			if (!isDocumentRecord(record.value)) {
 				continue;
 			}
 
···
 		collection: parsed.collection,
 		rkey: parsed.rkey,
 		record,
+	});
+}
+
+export async function deleteRecord(agent: Agent, atUri: string): Promise<void> {
+	const parsed = parseAtUri(atUri);
+	if (!parsed) throw new Error(`Invalid atUri format: ${atUri}`);
+	await agent.com.atproto.repo.deleteRecord({
+		repo: parsed.did,
+		collection: parsed.collection,
+		rkey: parsed.rkey,
 	});
 }
 

packages/cli/src/lib/markdown.test.ts

···
 	});
 
 	test("falls back to filepath when slugField not found in frontmatter", () => {
-		const slug = getSlugFromOptions("blog/my-post.md", {}, { slugField: "slug" });
+		const slug = getSlugFromOptions(
+			"blog/my-post.md",
+			{},
+			{ slugField: "slug" },
+		);
 		expect(slug).toBe("blog/my-post");
 	});
 
···
 ---
 Body`;
 
-		const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123");
+		const result = updateFrontmatterWithAtUri(
+			content,
+			"at://did:plc:abc/post/123",
+		);
 		expect(result).toContain('atUri: "at://did:plc:abc/post/123"');
 		expect(result).toContain("title: My Post");
 	});
···
 +++
 Body`;
 
-		const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123");
+		const result = updateFrontmatterWithAtUri(
+			content,
+			"at://did:plc:abc/post/123",
+		);
 		expect(result).toContain('atUri = "at://did:plc:abc/post/123"');
 	});
 
 	test("creates frontmatter with atUri when none exists", () => {
 		const content = "# My Post\n\nSome body text";
 
-		const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123");
+		const result = updateFrontmatterWithAtUri(
+			content,
+			"at://did:plc:abc/post/123",
+		);
 		expect(result).toContain('atUri: "at://did:plc:abc/post/123"');
 		expect(result).toContain("---");
 		expect(result).toContain("# My Post\n\nSome body text");
···
 ---
 Body`;
 
-		const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999");
+		const result = updateFrontmatterWithAtUri(
+			content,
+			"at://did:plc:new/post/999",
+		);
 		expect(result).toContain('atUri: "at://did:plc:new/post/999"');
 		expect(result).not.toContain("old");
 	});
···
 +++
 Body`;
 
-		const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999");
+		const result = updateFrontmatterWithAtUri(
+			content,
+			"at://did:plc:new/post/999",
+		);
 		expect(result).toContain('atUri = "at://did:plc:new/post/999"');
 		expect(result).not.toContain("old");
 	});
···
 		};
 		expect(getTextContent(post)).toBe("Heading\n\nParagraph");
 	});
-});
+});

packages/cli/src/lib/markdown.ts

···
 	const match = content.match(frontmatterRegex);
 
 	if (!match) {
-    const [, titleMatch] = content.trim().match(/^# (.+)$/m) || []
-    const title = titleMatch ?? ""
-    const [publishDate] = new Date().toISOString().split("T")
+		const [, titleMatch] = content.trim().match(/^# (.+)$/m) || [];
+		const title = titleMatch ?? "";
+		const [publishDate] = new Date().toISOString().split("T");
 
-    return {
-      frontmatter: {
-        title,
-        publishDate: publishDate ?? ""
-      },
-      body: content,
-      rawFrontmatter: {
-        title:
-        publishDate
-      }
-    }
+		return {
+			frontmatter: {
+				title,
+				publishDate: publishDate ?? "",
+			},
+			body: content,
+			rawFrontmatter: {
+				title: publishDate,
+			},
+		};
 	}
 
 	const delimiter = match[1];
···
 	const afterEnd = rawContent.slice(frontmatterEndIndex);
 
 	return `${beforeEnd}${atUriEntry}\n${afterEnd}`;
+}
+
+export function removeFrontmatterAtUri(rawContent: string): string {
+	const frontmatterRegex = /^(---|\+\+\+|\*\*\*)\n([\s\S]*?)\n\1\n/;
+	const match = rawContent.match(frontmatterRegex);
+	if (!match) return rawContent;
+
+	const delimiter = match[1];
+	const frontmatterStr = match[2] ?? "";
+
+	// Remove the atUri line
+	const lines = frontmatterStr
+		.split("\n")
+		.filter((line) => !line.match(/^\s*atUri\s*[=:]\s*/));
+
+	// Check if remaining frontmatter has any non-empty lines
+	const hasContent = lines.some((line) => line.trim() !== "");
+
+	const afterFrontmatter = rawContent.slice(match[0].length);
+
+	if (!hasContent) {
+		// Remove entire frontmatter block, trim leading newlines
+		return afterFrontmatter.replace(/^\n+/, "");
+	}
+
+	return `${delimiter}\n${lines.join("\n")}\n${delimiter}\n${afterFrontmatter}`;
 }
 
 export function stripMarkdownForText(markdown: string): string {

packages/cli/src/lib/types.ts

···
 
 export interface PostFrontmatter {
 	title: string;
-  theme?: string
-  fontFamily?: string
-  fontSize?: number
+	theme?: string;
+	fontFamily?: string;
+	fontSize?: number;
 	description?: string;
 	publishDate: string;
 	tags?: string[];

packages/cli/src/lib/utils.ts

···
+import * as fs from "node:fs/promises";
+
+export async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}