+85

CLAUDE.md

··· 1 1 + # CLAUDE.md 2 2 + 3 3 + This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. 4 4 + 5 5 + ## Project Overview 6 6 + 7 7 + Sequoia is a CLI tool for publishing Markdown documents with frontmatter to the AT Protocol (Bluesky's decentralized social network). It converts blog posts into ATProto records (`site.standard.document`, `space.litenote.note`) and publishes them to a user's PDS. 8 8 + 9 9 + Website: <https://sequoia.pub> 10 10 + 11 11 + ## Monorepo Structure 12 12 + 13 13 + - **`packages/cli/`** — Main CLI package (the core product) 14 14 + - **`docs/`** — Documentation website (Vocs-based, deployed to Cloudflare Pages) 15 15 + 16 16 + Bun workspaces manage the monorepo. 17 17 + 18 18 + ## Commands 19 19 + 20 20 + ```bash 21 21 + # Build CLI 22 22 + bun run build:cli 23 23 + 24 24 + # Run CLI in dev (build + link) 25 25 + cd packages/cli && bun run dev 26 26 + 27 27 + # Run tests 28 28 + bun run test:cli 29 29 + 30 30 + # Run a single test file 31 31 + cd packages/cli && bun test src/lib/markdown.test.ts 32 32 + 33 33 + # Lint (auto-fix) 34 34 + cd packages/cli && bun run lint 35 35 + 36 36 + # Format (auto-fix) 37 37 + cd packages/cli && bun run format 38 38 + 39 39 + # Docs dev server 40 40 + bun run dev:docs 41 41 + ``` 42 42 + 43 43 + ## Architecture 44 44 + 45 45 + **Entry point:** `packages/cli/src/index.ts` — Uses `cmd-ts` for type-safe subcommand routing. 46 46 + 47 47 + **Commands** (`src/commands/`): 48 48 + 49 49 + - `publish` — Core workflow: scans markdown files, publishes to ATProto 50 50 + - `sync` — Fetches published records state from ATProto 51 51 + - `update` — Updates existing records 52 52 + - `auth` — Multi-identity management (app-password + OAuth) 53 53 + - `init` — Interactive config setup 54 54 + - `inject` — Injects verification links into static HTML output 55 55 + - `login` — Legacy auth (deprecated) 56 56 + 57 57 + **Libraries** (`src/lib/`): 58 58 + 59 59 + - `atproto.ts` — ATProto API wrapper (two client types: AtpAgent for app-password, OAuth client) 60 60 + - `config.ts` — Loads `sequoia.json` config and `.sequoia-state.json` state files 61 61 + - `credentials.ts` — Multi-identity credential storage at `~/.config/sequoia/credentials.json` (0o600 permissions) 62 62 + - `markdown.ts` — Frontmatter parsing (YAML/TOML), content hashing, atUri injection 63 63 + 64 64 + **Extensions** (`src/extensions/`): 65 65 + 66 66 + - `litenote.ts` — Creates `space.litenote.note` records with embedded images 67 67 + 68 68 + ## Key Patterns 69 69 + 70 70 + - **Config resolution:** `sequoia.json` is found by searching up the directory tree 71 71 + - **Frontmatter formats:** YAML (`---`), TOML (`+++`), and alternative (`***`) delimiters 72 72 + - **Credential types:** App-password (PDS URL + identifier + password) and OAuth (DID + handle) 73 73 + - **Build:** `bun build src/index.ts --target node --outdir dist` 74 74 + 75 75 + ## Tooling 76 76 + 77 77 + - **Runtime/bundler:** Bun 78 78 + - **Linter/formatter:** Biome (tabs, double quotes) 79 79 + - **Test runner:** Bun's native test runner 80 80 + - **CLI framework:** `cmd-ts` 81 81 + - **Interactive UI:** `@clack/prompts` 82 82 + 83 83 + ## Git Conventions 84 84 + 85 85 + Never add 'Co-authored-by' lines to git commits unless explicitly asked.

+4 -16

action.yml

··· 34 34 - name: Setup Bun 35 35 uses: oven-sh/setup-bun@v2 36 36 37 37 - - name: Checkout Sequoia CLI 38 38 - uses: actions/checkout@v4 39 39 - with: 40 40 - repository: ${{ github.action_repository }} 41 41 - ref: ${{ github.action_ref }} 42 42 - path: .sequoia-action 43 43 - 44 37 - name: Build and install Sequoia CLI 45 38 shell: bash 46 39 run: | 47 47 - cd .sequoia-action 40 40 + cd ${{ github.action_path }} 48 41 bun install 49 42 bun run build:cli 50 43 bun link --cwd packages/cli ··· 72 65 fi 73 66 sequoia publish $FLAGS 74 67 75 75 - - name: Clean up action checkout 76 76 - shell: bash 77 77 - run: rm -rf .sequoia-action 78 78 - 79 68 - name: Commit back changes 80 69 if: inputs.commit-back == 'true' 81 70 shell: bash 82 71 working-directory: ${{ inputs.working-directory }} 83 72 run: | 84 84 - git config user.name "github-actions[bot]" 85 85 - git config user.email "41898282+github-actions[bot]@users.noreply.github.com" 86 86 - git add -A .sequoia-state.json 87 87 - git add -A *.md **/*.md || true 73 73 + git config user.name "$(git log -1 --format='%an')" 74 74 + git config user.email "$(git log -1 --format='%ae')" 75 75 + git add -A -- '**/*.md' || true 88 76 if git diff --cached --quiet; then 89 77 echo "No changes to commit" 90 78 else

+2 -1

package.json

··· 11 11 "build:docs": "cd docs && bun run build", 12 12 "build:cli": "cd packages/cli && bun run build", 13 13 "deploy:docs": "cd docs && bun run deploy", 14 14 - "deploy:cli": "cd packages/cli && bun run deploy" 14 14 + "deploy:cli": "cd packages/cli && bun run deploy", 15 15 + "test:cli": "cd packages/cli && bun test" 15 16 }, 16 17 "devDependencies": { 17 18 "@types/bun": "latest",

-79

packages/cli/src/commands/publish-lite.ts

··· 1 1 - import { Agent } from "@atproto/api" 2 2 - import { BlogPost } from "../lib/types" 3 3 - 4 4 - const LEXICON = "space.litenote.note" 5 5 - const MAX_CONTENT = 10000 6 6 - 7 7 - export async function createNote( 8 8 - agent: Agent, 9 9 - post: BlogPost, 10 10 - atUri: string, 11 11 - ): Promise<void> { 12 12 - // Parse the atUri to get the site.standard.document rkey 13 13 - // Format: at://did:plc:xxx/collection/rkey 14 14 - const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/); 15 15 - if (!uriMatch) { 16 16 - throw new Error(`Invalid atUri format: ${atUri}`); 17 17 - } 18 18 - 19 19 - const [, , , rkey] = uriMatch; 20 20 - const publishDate = new Date(post.frontmatter.publishDate).toISOString(); 21 21 - const trimmedContent = post.content.trim(); 22 22 - const titleMatch = trimmedContent.match(/^# (.+)$/m); 23 23 - const title = titleMatch ? titleMatch[1] : post.frontmatter.title; 24 24 - 25 25 - const record: Record<string, unknown> = { 26 26 - $type: LEXICON, 27 27 - title, 28 28 - content: trimmedContent.slice(0, MAX_CONTENT), 29 29 - createdAt: publishDate, 30 30 - publishedAt: publishDate, 31 31 - }; 32 32 - 33 33 - const response = await agent.com.atproto.repo.createRecord({ 34 34 - repo: agent.did!, 35 35 - collection: LEXICON, 36 36 - record, 37 37 - rkey, 38 38 - validate: false 39 39 - }); 40 40 - 41 41 - console.log("\n\n create -", response); 42 42 - } 43 43 - 44 44 - export async function updateNote( 45 45 - agent: Agent, 46 46 - post: BlogPost, 47 47 - atUri: string, 48 48 - ): Promise<void> { 49 49 - // Parse the atUri to get the rkey 50 50 - // Format: at://did:plc:xxx/collection/rkey 51 51 - const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/); 52 52 - if (!uriMatch) { 53 53 - throw new Error(`Invalid atUri format: ${atUri}`); 54 54 - } 55 55 - 56 56 - const [, , , rkey] = uriMatch; 57 57 - const publishDate = new Date(post.frontmatter.publishDate).toISOString(); 58 58 - const trimmedContent = post.content.trim(); 59 59 - const titleMatch = trimmedContent.match(/^# (.+)$/m); 60 60 - const title = titleMatch ? titleMatch[1] : post.frontmatter.title; 61 61 - 62 62 - const record: Record<string, unknown> = { 63 63 - $type: LEXICON, 64 64 - title, 65 65 - content: trimmedContent.slice(0, MAX_CONTENT), 66 66 - createdAt: publishDate, 67 67 - publishedAt: publishDate, 68 68 - }; 69 69 - 70 70 - const response = await agent.com.atproto.repo.putRecord({ 71 71 - repo: agent.did!, 72 72 - collection: LEXICON, 73 73 - rkey: rkey!, 74 74 - record, 75 75 - validate: false 76 76 - }); 77 77 - 78 78 - console.log("\n\n update -", response); 79 79 - }

+74 -8

packages/cli/src/commands/publish.ts

··· 25 25 } from "../lib/markdown"; 26 26 import type { BlogPost, BlobObject, StrongRef } from "../lib/types"; 27 27 import { exitOnCancel } from "../lib/prompts"; 28 28 - import { createNote, updateNote } from "./publish-lite" 28 28 + import { createNote, updateNote, findPostsWithStaleLinks, type NoteOptions } from "../extensions/litenote" 29 29 30 30 export const publishCommand = command({ 31 31 name: "publish", ··· 158 158 const postsToPublish: Array<{ 159 159 post: BlogPost; 160 160 action: "create" | "update"; 161 161 - reason: string; 161 161 + reason: "content changed" | "forced" | "new post" | "missing state"; 162 162 }> = []; 163 163 const draftPosts: BlogPost[] = []; 164 164 ··· 180 180 reason: "forced", 181 181 }); 182 182 } else if (!postState) { 183 183 - // New post 184 183 postsToPublish.push({ 185 184 post, 186 186 - action: "create", 187 187 - reason: "new post", 185 185 + action: post.frontmatter.atUri ? "update" : "create", 186 186 + reason: post.frontmatter.atUri ? "missing state" : "new post", 188 187 }); 189 188 } else if (postState.contentHash !== contentHash) { 190 189 // Changed post ··· 234 233 } 235 234 } 236 235 237 237 - log.message(` ${icon} ${post.frontmatter.title} (${reason})${bskyNote}`); 236 236 + log.message(` ${icon} ${post.filePath} (${reason})${bskyNote}`); 238 237 } 239 238 240 239 if (dryRun) { ··· 265 264 let errorCount = 0; 266 265 let bskyPostCount = 0; 267 266 267 267 + const context: NoteOptions = { 268 268 + contentDir, 269 269 + imagesDir, 270 270 + allPosts: posts, 271 271 + }; 272 272 + 273 273 + // Pass 1: Create/update document records and collect note queue 274 274 + const noteQueue: Array<{ 275 275 + post: BlogPost; 276 276 + action: "create" | "update"; 277 277 + atUri: string; 278 278 + }> = []; 279 279 + 268 280 for (const { post, action } of postsToPublish) { 269 281 s.start(`Publishing: ${post.frontmatter.title}`); 282 282 + 283 283 + // Init publish date 284 284 + if (!post.frontmatter.publishDate) { 285 285 + const [publishDate] = new Date().toISOString().split("T") 286 286 + post.frontmatter.publishDate = publishDate! 287 287 + } 270 288 271 289 try { 272 290 // Handle cover image upload ··· 300 318 301 319 if (action === "create") { 302 320 atUri = await createDocument(agent, post, config, coverImage); 303 303 - await createNote(agent, post, atUri) 321 321 + post.frontmatter.atUri = atUri; 304 322 s.stop(`Created: ${atUri}`); 305 323 306 324 // Update frontmatter with atUri ··· 317 335 } else { 318 336 atUri = post.frontmatter.atUri!; 319 337 await updateDocument(agent, post, atUri, config, coverImage); 320 320 - await updateNote(agent, post, atUri) 321 338 s.stop(`Updated: ${atUri}`); 322 339 323 340 // For updates, rawContent already has atUri ··· 375 392 slug: post.slug, 376 393 bskyPostRef, 377 394 }; 395 395 + 396 396 + noteQueue.push({ post, action, atUri }); 378 397 } catch (error) { 379 398 const errorMessage = 380 399 error instanceof Error ? error.message : String(error); 381 400 s.stop(`Error publishing "${path.basename(post.filePath)}"`); 382 401 log.error(` ${errorMessage}`); 383 402 errorCount++; 403 403 + } 404 404 + } 405 405 + 406 406 + // Pass 2: Create/update litenote notes (atUris are now available for link resolution) 407 407 + for (const { post, action, atUri } of noteQueue) { 408 408 + try { 409 409 + if (action === "create") { 410 410 + await createNote(agent, post, atUri, context); 411 411 + } else { 412 412 + await updateNote(agent, post, atUri, context); 413 413 + } 414 414 + } catch (error) { 415 415 + log.warn( 416 416 + `Failed to create note for "${post.frontmatter.title}": ${error instanceof Error ? error.message : String(error)}`, 417 417 + ); 418 418 + } 419 419 + } 420 420 + 421 421 + // Re-process already-published posts with stale links to newly created posts 422 422 + const newlyCreatedSlugs = noteQueue 423 423 + .filter((r) => r.action === "create") 424 424 + .map((r) => r.post.slug); 425 425 + 426 426 + if (newlyCreatedSlugs.length > 0) { 427 427 + const batchFilePaths = new Set(noteQueue.map((r) => r.post.filePath)); 428 428 + const stalePosts = findPostsWithStaleLinks( 429 429 + posts, 430 430 + newlyCreatedSlugs, 431 431 + batchFilePaths, 432 432 + ); 433 433 + 434 434 + for (const stalePost of stalePosts) { 435 435 + try { 436 436 + s.start(`Updating links in: ${stalePost.frontmatter.title}`); 437 437 + await updateNote( 438 438 + agent, 439 439 + stalePost, 440 440 + stalePost.frontmatter.atUri!, 441 441 + context, 442 442 + ); 443 443 + s.stop(`Updated links: ${stalePost.frontmatter.title}`); 444 444 + } catch (error) { 445 445 + s.stop(`Failed to update links: ${stalePost.frontmatter.title}`); 446 446 + log.warn( 447 447 + ` ${error instanceof Error ? error.message : String(error)}`, 448 448 + ); 449 449 + } 384 450 } 385 451 } 386 452

+17 -2

packages/cli/src/commands/sync.ts

··· 13 13 import { 14 14 scanContentDirectory, 15 15 getContentHash, 16 16 + getTextContent, 16 17 updateFrontmatterWithAtUri, 17 18 } from "../lib/markdown"; 18 19 import { exitOnCancel } from "../lib/prompts"; ··· 177 178 log.message(` URI: ${doc.uri}`); 178 179 log.message(` File: ${path.basename(localPost.filePath)}`); 179 180 180 180 - // Update state (use relative path from config directory) 181 181 - const contentHash = await getContentHash(localPost.rawContent); 181 181 + // Compare local text content with PDS text content to detect changes. 182 182 + // We must avoid storing the local rawContent hash blindly, because 183 183 + // that would make publish think nothing changed even when content 184 184 + // was modified since the last publish. 185 185 + const localTextContent = getTextContent( 186 186 + localPost, 187 187 + config.textContentField, 188 188 + ); 189 189 + const contentMatchesPDS = 190 190 + localTextContent.slice(0, 10000) === doc.value.textContent; 191 191 + 192 192 + // If local content matches PDS, store the local hash (up to date). 193 193 + // If it differs, store empty hash so publish detects the change. 194 194 + const contentHash = contentMatchesPDS 195 195 + ? await getContentHash(localPost.rawContent) 196 196 + : ""; 182 197 const relativeFilePath = path.relative(configDir, localPost.filePath); 183 198 state.posts[relativeFilePath] = { 184 199 contentHash,

+238

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

··· 1 1 + import { describe, expect, test } from "bun:test"; 2 2 + import { resolveInternalLinks, findPostsWithStaleLinks } from "./litenote"; 3 3 + import type { BlogPost } from "../lib/types"; 4 4 + 5 5 + function makePost( 6 6 + slug: string, 7 7 + atUri?: string, 8 8 + options?: { content?: string; draft?: boolean; filePath?: string }, 9 9 + ): BlogPost { 10 10 + return { 11 11 + filePath: options?.filePath ?? `content/${slug}.md`, 12 12 + slug, 13 13 + frontmatter: { 14 14 + title: slug, 15 15 + publishDate: "2024-01-01", 16 16 + atUri, 17 17 + draft: options?.draft, 18 18 + }, 19 19 + content: options?.content ?? "", 20 20 + rawContent: "", 21 21 + rawFrontmatter: {}, 22 22 + }; 23 23 + } 24 24 + 25 25 + describe("resolveInternalLinks", () => { 26 26 + test("strips link for unpublished local path", () => { 27 27 + const posts = [makePost("other-post")]; 28 28 + const content = "See [my post](./other-post)"; 29 29 + expect(resolveInternalLinks(content, posts)).toBe("See my post"); 30 30 + }); 31 31 + 32 32 + test("rewrites published link to litenote atUri", () => { 33 33 + const posts = [ 34 34 + makePost( 35 35 + "other-post", 36 36 + "at://did:plc:abc/site.standard.document/abc123", 37 37 + ), 38 38 + ]; 39 39 + const content = "See [my post](./other-post)"; 40 40 + expect(resolveInternalLinks(content, posts)).toBe( 41 41 + "See [my post](at://did:plc:abc/space.litenote.note/abc123)", 42 42 + ); 43 43 + }); 44 44 + 45 45 + test("leaves external links unchanged", () => { 46 46 + const posts = [makePost("other-post")]; 47 47 + const content = "See [example](https://example.com)"; 48 48 + expect(resolveInternalLinks(content, posts)).toBe( 49 49 + "See [example](https://example.com)", 50 50 + ); 51 51 + }); 52 52 + 53 53 + test("leaves anchor links unchanged", () => { 54 54 + const posts: BlogPost[] = []; 55 55 + const content = "See [section](#heading)"; 56 56 + expect(resolveInternalLinks(content, posts)).toBe( 57 57 + "See [section](#heading)", 58 58 + ); 59 59 + }); 60 60 + 61 61 + test("handles .md extension in link path", () => { 62 62 + const posts = [ 63 63 + makePost( 64 64 + "guide", 65 65 + "at://did:plc:abc/site.standard.document/guide123", 66 66 + ), 67 67 + ]; 68 68 + const content = "Read the [guide](guide.md)"; 69 69 + expect(resolveInternalLinks(content, posts)).toBe( 70 70 + "Read the [guide](at://did:plc:abc/space.litenote.note/guide123)", 71 71 + ); 72 72 + }); 73 73 + 74 74 + test("handles nested slug matching", () => { 75 75 + const posts = [ 76 76 + makePost( 77 77 + "blog/my-post", 78 78 + "at://did:plc:abc/site.standard.document/rkey1", 79 79 + ), 80 80 + ]; 81 81 + const content = "See [post](my-post)"; 82 82 + expect(resolveInternalLinks(content, posts)).toBe( 83 83 + "See [post](at://did:plc:abc/space.litenote.note/rkey1)", 84 84 + ); 85 85 + }); 86 86 + 87 87 + test("does not rewrite image embeds", () => { 88 88 + const posts = [ 89 89 + makePost( 90 90 + "photo", 91 91 + "at://did:plc:abc/site.standard.document/photo1", 92 92 + ), 93 93 + ]; 94 94 + const content = ""; 95 95 + expect(resolveInternalLinks(content, posts)).toBe(""); 96 96 + }); 97 97 + 98 98 + test("does not rewrite @mention links", () => { 99 99 + const posts = [ 100 100 + makePost( 101 101 + "mention", 102 102 + "at://did:plc:abc/site.standard.document/m1", 103 103 + ), 104 104 + ]; 105 105 + const content = "@[name](mention)"; 106 106 + expect(resolveInternalLinks(content, posts)).toBe("@[name](mention)"); 107 107 + }); 108 108 + 109 109 + test("handles multiple links in same content", () => { 110 110 + const posts = [ 111 111 + makePost( 112 112 + "published", 113 113 + "at://did:plc:abc/site.standard.document/pub1", 114 114 + ), 115 115 + makePost("unpublished"), 116 116 + ]; 117 117 + const content = 118 118 + "See [a](published) and [b](unpublished) and [c](https://ext.com)"; 119 119 + expect(resolveInternalLinks(content, posts)).toBe( 120 120 + "See [a](at://did:plc:abc/space.litenote.note/pub1) and b and [c](https://ext.com)", 121 121 + ); 122 122 + }); 123 123 + 124 124 + test("handles index path normalization", () => { 125 125 + const posts = [ 126 126 + makePost( 127 127 + "docs", 128 128 + "at://did:plc:abc/site.standard.document/docs1", 129 129 + ), 130 130 + ]; 131 131 + const content = "See [docs](./docs/index)"; 132 132 + expect(resolveInternalLinks(content, posts)).toBe( 133 133 + "See [docs](at://did:plc:abc/space.litenote.note/docs1)", 134 134 + ); 135 135 + }); 136 136 + }); 137 137 + 138 138 + describe("findPostsWithStaleLinks", () => { 139 139 + test("finds published post containing link to a newly created slug", () => { 140 140 + const posts = [ 141 141 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 142 142 + content: "Check out [post B](./post-b)", 143 143 + }), 144 144 + ]; 145 145 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 146 146 + expect(result).toHaveLength(1); 147 147 + expect(result[0]!.slug).toBe("post-a"); 148 148 + }); 149 149 + 150 150 + test("excludes posts in the exclude set (current batch)", () => { 151 151 + const posts = [ 152 152 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 153 153 + content: "Check out [post B](./post-b)", 154 154 + }), 155 155 + ]; 156 156 + const result = findPostsWithStaleLinks( 157 157 + posts, 158 158 + ["post-b"], 159 159 + new Set(["content/post-a.md"]), 160 160 + ); 161 161 + expect(result).toHaveLength(0); 162 162 + }); 163 163 + 164 164 + test("excludes unpublished posts (no atUri)", () => { 165 165 + const posts = [ 166 166 + makePost("post-a", undefined, { 167 167 + content: "Check out [post B](./post-b)", 168 168 + }), 169 169 + ]; 170 170 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 171 171 + expect(result).toHaveLength(0); 172 172 + }); 173 173 + 174 174 + test("excludes drafts", () => { 175 175 + const posts = [ 176 176 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 177 177 + content: "Check out [post B](./post-b)", 178 178 + draft: true, 179 179 + }), 180 180 + ]; 181 181 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 182 182 + expect(result).toHaveLength(0); 183 183 + }); 184 184 + 185 185 + test("ignores external links", () => { 186 186 + const posts = [ 187 187 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 188 188 + content: "Check out [post B](https://example.com/post-b)", 189 189 + }), 190 190 + ]; 191 191 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 192 192 + expect(result).toHaveLength(0); 193 193 + }); 194 194 + 195 195 + test("ignores image embeds", () => { 196 196 + const posts = [ 197 197 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 198 198 + content: "", 199 199 + }), 200 200 + ]; 201 201 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 202 202 + expect(result).toHaveLength(0); 203 203 + }); 204 204 + 205 205 + test("ignores @mention links", () => { 206 206 + const posts = [ 207 207 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 208 208 + content: "@[post B](./post-b)", 209 209 + }), 210 210 + ]; 211 211 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 212 212 + expect(result).toHaveLength(0); 213 213 + }); 214 214 + 215 215 + test("handles nested slug matching", () => { 216 216 + const posts = [ 217 217 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 218 218 + content: "Check out [post](my-post)", 219 219 + }), 220 220 + ]; 221 221 + const result = findPostsWithStaleLinks( 222 222 + posts, 223 223 + ["blog/my-post"], 224 224 + new Set(), 225 225 + ); 226 226 + expect(result).toHaveLength(1); 227 227 + }); 228 228 + 229 229 + test("does not match posts without matching links", () => { 230 230 + const posts = [ 231 231 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 232 232 + content: "Check out [post C](./post-c)", 233 233 + }), 234 234 + ]; 235 235 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 236 236 + expect(result).toHaveLength(0); 237 237 + }); 238 238 + });

+285

packages/cli/src/extensions/litenote.ts

··· 1 1 + import { Agent } from "@atproto/api" 2 2 + import * as fs from "node:fs/promises" 3 3 + import * as path from "node:path" 4 4 + import mimeTypes from "mime-types" 5 5 + import { BlogPost, BlobObject } from "../lib/types" 6 6 + 7 7 + const LEXICON = "space.litenote.note" 8 8 + const MAX_CONTENT = 10000 9 9 + 10 10 + interface ImageRecord { 11 11 + image: BlobObject 12 12 + alt?: string 13 13 + } 14 14 + 15 15 + export interface NoteOptions { 16 16 + contentDir: string 17 17 + imagesDir?: string 18 18 + allPosts: BlogPost[] 19 19 + } 20 20 + 21 21 + async function fileExists(filePath: string): Promise<boolean> { 22 22 + try { 23 23 + await fs.access(filePath) 24 24 + return true 25 25 + } catch { 26 26 + return false 27 27 + } 28 28 + } 29 29 + 30 30 + export function isLocalPath(url: string): boolean { 31 31 + return ( 32 32 + !url.startsWith("http://") && 33 33 + !url.startsWith("https://") && 34 34 + !url.startsWith("#") && 35 35 + !url.startsWith("mailto:") 36 36 + ) 37 37 + } 38 38 + 39 39 + function getImageCandidates( 40 40 + src: string, 41 41 + postFilePath: string, 42 42 + contentDir: string, 43 43 + imagesDir?: string, 44 44 + ): string[] { 45 45 + const candidates = [ 46 46 + path.resolve(path.dirname(postFilePath), src), 47 47 + path.resolve(contentDir, src), 48 48 + ] 49 49 + if (imagesDir) { 50 50 + candidates.push(path.resolve(imagesDir, src)) 51 51 + const baseName = path.basename(imagesDir) 52 52 + const idx = src.indexOf(baseName) 53 53 + if (idx !== -1) { 54 54 + const after = src.substring(idx + baseName.length).replace(/^[/\\]/, "") 55 55 + candidates.push(path.resolve(imagesDir, after)) 56 56 + } 57 57 + } 58 58 + return candidates 59 59 + } 60 60 + 61 61 + async function uploadBlob( 62 62 + agent: Agent, 63 63 + candidates: string[], 64 64 + ): Promise<BlobObject | undefined> { 65 65 + for (const filePath of candidates) { 66 66 + if (!(await fileExists(filePath))) continue 67 67 + 68 68 + try { 69 69 + const imageBuffer = await fs.readFile(filePath) 70 70 + if (imageBuffer.byteLength === 0) continue 71 71 + const mimeType = mimeTypes.lookup(filePath) || "application/octet-stream" 72 72 + const response = await agent.com.atproto.repo.uploadBlob( 73 73 + new Uint8Array(imageBuffer), 74 74 + { encoding: mimeType }, 75 75 + ) 76 76 + return { 77 77 + $type: "blob", 78 78 + ref: { $link: response.data.blob.ref.toString() }, 79 79 + mimeType, 80 80 + size: imageBuffer.byteLength, 81 81 + } 82 82 + } catch {} 83 83 + } 84 84 + return undefined 85 85 + } 86 86 + 87 87 + async function processImages( 88 88 + agent: Agent, 89 89 + content: string, 90 90 + postFilePath: string, 91 91 + contentDir: string, 92 92 + imagesDir?: string, 93 93 + ): Promise<{ content: string; images: ImageRecord[] }> { 94 94 + const images: ImageRecord[] = [] 95 95 + const uploadCache = new Map<string, BlobObject>() 96 96 + let processedContent = content 97 97 + 98 98 + const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g 99 99 + const matches = [...content.matchAll(imageRegex)] 100 100 + 101 101 + for (const match of matches) { 102 102 + const fullMatch = match[0] 103 103 + const alt = match[1] ?? "" 104 104 + const src = match[2]! 105 105 + if (!isLocalPath(src)) continue 106 106 + 107 107 + let blob = uploadCache.get(src) 108 108 + if (!blob) { 109 109 + const candidates = getImageCandidates(src, postFilePath, contentDir, imagesDir) 110 110 + blob = await uploadBlob(agent, candidates) 111 111 + if (!blob) continue 112 112 + uploadCache.set(src, blob) 113 113 + } 114 114 + 115 115 + images.push({ image: blob, alt: alt || undefined }) 116 116 + processedContent = processedContent.replace( 117 117 + fullMatch, 118 118 + ``, 119 119 + ) 120 120 + } 121 121 + 122 122 + return { content: processedContent, images } 123 123 + } 124 124 + 125 125 + export function resolveInternalLinks( 126 126 + content: string, 127 127 + allPosts: BlogPost[], 128 128 + ): string { 129 129 + const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g 130 130 + 131 131 + return content.replace(linkRegex, (fullMatch, text, url) => { 132 132 + if (!isLocalPath(url)) return fullMatch 133 133 + 134 134 + // Normalize to a slug-like string for comparison 135 135 + const normalized = url 136 136 + .replace(/^\.?\/?/, "") 137 137 + .replace(/\/?$/, "") 138 138 + .replace(/\.mdx?$/, "") 139 139 + .replace(/\/index$/, "") 140 140 + 141 141 + const matchedPost = allPosts.find((p) => { 142 142 + if (!p.frontmatter.atUri) return false 143 143 + return ( 144 144 + p.slug === normalized || 145 145 + p.slug.endsWith(`/${normalized}`) || 146 146 + normalized.endsWith(`/${p.slug}`) 147 147 + ) 148 148 + }) 149 149 + 150 150 + if (!matchedPost) return text 151 151 + 152 152 + const noteUri = matchedPost.frontmatter.atUri!.replace( 153 153 + /\/[^/]+\/([^/]+)$/, 154 154 + `/space.litenote.note/$1`, 155 155 + ) 156 156 + return `[${text}](${noteUri})` 157 157 + }) 158 158 + } 159 159 + 160 160 + async function processNoteContent( 161 161 + agent: Agent, 162 162 + post: BlogPost, 163 163 + options: NoteOptions, 164 164 + ): Promise<{ content: string; images: ImageRecord[] }> { 165 165 + let content = post.content.trim() 166 166 + 167 167 + content = resolveInternalLinks(content, options.allPosts) 168 168 + 169 169 + const result = await processImages( 170 170 + agent, content, post.filePath, options.contentDir, options.imagesDir, 171 171 + ) 172 172 + 173 173 + return result 174 174 + } 175 175 + 176 176 + function parseRkey(atUri: string): string { 177 177 + const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/) 178 178 + if (!uriMatch) { 179 179 + throw new Error(`Invalid atUri format: ${atUri}`) 180 180 + } 181 181 + return uriMatch[3]! 182 182 + } 183 183 + 184 184 + export async function createNote( 185 185 + agent: Agent, 186 186 + post: BlogPost, 187 187 + atUri: string, 188 188 + options: NoteOptions, 189 189 + ): Promise<void> { 190 190 + const rkey = parseRkey(atUri) 191 191 + const publishDate = new Date(post.frontmatter.publishDate).toISOString() 192 192 + const trimmedContent = post.content.trim() 193 193 + const titleMatch = trimmedContent.match(/^# (.+)$/m) 194 194 + const title = titleMatch ? titleMatch[1] : post.frontmatter.title 195 195 + 196 196 + const { content, images } = await processNoteContent(agent, post, options) 197 197 + 198 198 + const record: Record<string, unknown> = { 199 199 + $type: LEXICON, 200 200 + title, 201 201 + content: content.slice(0, MAX_CONTENT), 202 202 + createdAt: publishDate, 203 203 + publishedAt: publishDate, 204 204 + } 205 205 + 206 206 + if (images.length > 0) { 207 207 + record.images = images 208 208 + } 209 209 + 210 210 + await agent.com.atproto.repo.createRecord({ 211 211 + repo: agent.did!, 212 212 + collection: LEXICON, 213 213 + record, 214 214 + rkey, 215 215 + validate: false, 216 216 + }) 217 217 + } 218 218 + 219 219 + export async function updateNote( 220 220 + agent: Agent, 221 221 + post: BlogPost, 222 222 + atUri: string, 223 223 + options: NoteOptions, 224 224 + ): Promise<void> { 225 225 + const rkey = parseRkey(atUri) 226 226 + const publishDate = new Date(post.frontmatter.publishDate).toISOString() 227 227 + const trimmedContent = post.content.trim() 228 228 + const titleMatch = trimmedContent.match(/^# (.+)$/m) 229 229 + const title = titleMatch ? titleMatch[1] : post.frontmatter.title 230 230 + 231 231 + const { content, images } = await processNoteContent(agent, post, options) 232 232 + 233 233 + const record: Record<string, unknown> = { 234 234 + $type: LEXICON, 235 235 + title, 236 236 + content: content.slice(0, MAX_CONTENT), 237 237 + createdAt: publishDate, 238 238 + publishedAt: publishDate, 239 239 + } 240 240 + 241 241 + if (images.length > 0) { 242 242 + record.images = images 243 243 + } 244 244 + 245 245 + await agent.com.atproto.repo.putRecord({ 246 246 + repo: agent.did!, 247 247 + collection: LEXICON, 248 248 + rkey: rkey!, 249 249 + record, 250 250 + validate: false, 251 251 + }) 252 252 + } 253 253 + 254 254 + export function findPostsWithStaleLinks( 255 255 + allPosts: BlogPost[], 256 256 + newSlugs: string[], 257 257 + excludeFilePaths: Set<string>, 258 258 + ): BlogPost[] { 259 259 + const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g 260 260 + 261 261 + return allPosts.filter((post) => { 262 262 + if (excludeFilePaths.has(post.filePath)) return false 263 263 + if (!post.frontmatter.atUri) return false 264 264 + if (post.frontmatter.draft) return false 265 265 + 266 266 + const matches = [...post.content.matchAll(linkRegex)] 267 267 + return matches.some((match) => { 268 268 + const url = match[2]! 269 269 + if (!isLocalPath(url)) return false 270 270 + 271 271 + const normalized = url 272 272 + .replace(/^\.?\/?/, "") 273 273 + .replace(/\/?$/, "") 274 274 + .replace(/\.mdx?$/, "") 275 275 + .replace(/\/index$/, "") 276 276 + 277 277 + return newSlugs.some( 278 278 + (slug) => 279 279 + slug === normalized || 280 280 + slug.endsWith(`/${normalized}`) || 281 281 + normalized.endsWith(`/${slug}`), 282 282 + ) 283 283 + }) 284 284 + }) 285 285 + }

+4 -23

packages/cli/src/lib/atproto.ts

··· 2 2 import * as mimeTypes from "mime-types"; 3 3 import * as fs from "node:fs/promises"; 4 4 import * as path from "node:path"; 5 5 - import { stripMarkdownForText } from "./markdown"; 5 5 + import { getTextContent } from "./markdown"; 6 6 import { getOAuthClient } from "./oauth-client"; 7 7 import type { 8 8 BlobObject, ··· 248 248 const pathPrefix = config.pathPrefix || "/posts"; 249 249 const postPath = `${pathPrefix}/${post.slug}`; 250 250 const publishDate = new Date(post.frontmatter.publishDate); 251 251 - 252 252 - // Determine textContent: use configured field from frontmatter, or fallback to markdown body 253 253 - let textContent: string; 254 254 - if ( 255 255 - config.textContentField && 256 256 - post.rawFrontmatter?.[config.textContentField] 257 257 - ) { 258 258 - textContent = String(post.rawFrontmatter[config.textContentField]); 259 259 - } else { 260 260 - textContent = stripMarkdownForText(post.content); 261 261 - } 251 251 + const textContent = getTextContent(post, config.textContentField); 262 252 263 253 const record: Record<string, unknown> = { 264 254 $type: "site.standard.document", ··· 309 299 310 300 const pathPrefix = config.pathPrefix || "/posts"; 311 301 const postPath = `${pathPrefix}/${post.slug}`; 302 302 + 312 303 const publishDate = new Date(post.frontmatter.publishDate); 313 313 - 314 314 - // Determine textContent: use configured field from frontmatter, or fallback to markdown body 315 315 - let textContent: string; 316 316 - if ( 317 317 - config.textContentField && 318 318 - post.rawFrontmatter?.[config.textContentField] 319 319 - ) { 320 320 - textContent = String(post.rawFrontmatter[config.textContentField]); 321 321 - } else { 322 322 - textContent = stripMarkdownForText(post.content); 323 323 - } 304 304 + const textContent = getTextContent(post, config.textContentField); 324 305 325 306 const record: Record<string, unknown> = { 326 307 $type: "site.standard.document",

+439

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

··· 1 1 + import { describe, expect, test } from "bun:test"; 2 2 + import { 3 3 + getContentHash, 4 4 + getSlugFromFilename, 5 5 + getSlugFromOptions, 6 6 + getTextContent, 7 7 + parseFrontmatter, 8 8 + stripMarkdownForText, 9 9 + updateFrontmatterWithAtUri, 10 10 + } from "./markdown"; 11 11 + 12 12 + describe("parseFrontmatter", () => { 13 13 + test("parses YAML frontmatter with --- delimiters", () => { 14 14 + const content = `--- 15 15 + title: My Post 16 16 + description: A description 17 17 + publishDate: 2024-01-15 18 18 + --- 19 19 + Hello world`; 20 20 + 21 21 + const result = parseFrontmatter(content); 22 22 + expect(result.frontmatter.title).toBe("My Post"); 23 23 + expect(result.frontmatter.description).toBe("A description"); 24 24 + expect(result.frontmatter.publishDate).toBe("2024-01-15"); 25 25 + expect(result.body).toBe("Hello world"); 26 26 + expect(result.rawFrontmatter.title).toBe("My Post"); 27 27 + }); 28 28 + 29 29 + test("parses TOML frontmatter with +++ delimiters", () => { 30 30 + const content = `+++ 31 31 + title = My Post 32 32 + description = A description 33 33 + date = 2024-01-15 34 34 + +++ 35 35 + Body content`; 36 36 + 37 37 + const result = parseFrontmatter(content); 38 38 + expect(result.frontmatter.title).toBe("My Post"); 39 39 + expect(result.frontmatter.description).toBe("A description"); 40 40 + expect(result.frontmatter.publishDate).toBe("2024-01-15"); 41 41 + expect(result.body).toBe("Body content"); 42 42 + }); 43 43 + 44 44 + test("parses *** delimited frontmatter", () => { 45 45 + const content = `*** 46 46 + title: Test 47 47 + *** 48 48 + Body`; 49 49 + 50 50 + const result = parseFrontmatter(content); 51 51 + expect(result.frontmatter.title).toBe("Test"); 52 52 + expect(result.body).toBe("Body"); 53 53 + }); 54 54 + 55 55 + test("handles no frontmatter - extracts title from heading", () => { 56 56 + const content = `# My Heading 57 57 + 58 58 + Some body text`; 59 59 + 60 60 + const result = parseFrontmatter(content); 61 61 + expect(result.frontmatter.title).toBe("My Heading"); 62 62 + expect(result.frontmatter.publishDate).toBeTruthy(); 63 63 + expect(result.body).toBe(content); 64 64 + }); 65 65 + 66 66 + test("handles no frontmatter and no heading", () => { 67 67 + const content = "Just plain text"; 68 68 + 69 69 + const result = parseFrontmatter(content); 70 70 + expect(result.frontmatter.title).toBe(""); 71 71 + expect(result.body).toBe(content); 72 72 + }); 73 73 + 74 74 + test("handles quoted string values", () => { 75 75 + const content = `--- 76 76 + title: "Quoted Title" 77 77 + description: 'Single Quoted' 78 78 + --- 79 79 + Body`; 80 80 + 81 81 + const result = parseFrontmatter(content); 82 82 + expect(result.rawFrontmatter.title).toBe("Quoted Title"); 83 83 + expect(result.rawFrontmatter.description).toBe("Single Quoted"); 84 84 + }); 85 85 + 86 86 + test("parses inline arrays", () => { 87 87 + const content = `--- 88 88 + title: Post 89 89 + tags: [javascript, typescript, "web dev"] 90 90 + --- 91 91 + Body`; 92 92 + 93 93 + const result = parseFrontmatter(content); 94 94 + expect(result.rawFrontmatter.tags).toEqual([ 95 95 + "javascript", 96 96 + "typescript", 97 97 + "web dev", 98 98 + ]); 99 99 + }); 100 100 + 101 101 + test("parses YAML multiline arrays", () => { 102 102 + const content = `--- 103 103 + title: Post 104 104 + tags: 105 105 + - javascript 106 106 + - typescript 107 107 + - web dev 108 108 + --- 109 109 + Body`; 110 110 + 111 111 + const result = parseFrontmatter(content); 112 112 + expect(result.rawFrontmatter.tags).toEqual([ 113 113 + "javascript", 114 114 + "typescript", 115 115 + "web dev", 116 116 + ]); 117 117 + }); 118 118 + 119 119 + test("parses boolean values", () => { 120 120 + const content = `--- 121 121 + title: Draft Post 122 122 + draft: true 123 123 + published: false 124 124 + --- 125 125 + Body`; 126 126 + 127 127 + const result = parseFrontmatter(content); 128 128 + expect(result.rawFrontmatter.draft).toBe(true); 129 129 + expect(result.rawFrontmatter.published).toBe(false); 130 130 + }); 131 131 + 132 132 + test("applies frontmatter field mappings", () => { 133 133 + const content = `--- 134 134 + nombre: Custom Title 135 135 + descripcion: Custom Desc 136 136 + fecha: 2024-06-01 137 137 + imagen: cover.jpg 138 138 + etiquetas: [a, b] 139 139 + borrador: true 140 140 + --- 141 141 + Body`; 142 142 + 143 143 + const mapping = { 144 144 + title: "nombre", 145 145 + description: "descripcion", 146 146 + publishDate: "fecha", 147 147 + coverImage: "imagen", 148 148 + tags: "etiquetas", 149 149 + draft: "borrador", 150 150 + }; 151 151 + 152 152 + const result = parseFrontmatter(content, mapping); 153 153 + expect(result.frontmatter.title).toBe("Custom Title"); 154 154 + expect(result.frontmatter.description).toBe("Custom Desc"); 155 155 + expect(result.frontmatter.publishDate).toBe("2024-06-01"); 156 156 + expect(result.frontmatter.ogImage).toBe("cover.jpg"); 157 157 + expect(result.frontmatter.tags).toEqual(["a", "b"]); 158 158 + expect(result.frontmatter.draft).toBe(true); 159 159 + }); 160 160 + 161 161 + test("falls back to common date field names", () => { 162 162 + const content = `--- 163 163 + title: Post 164 164 + date: 2024-03-20 165 165 + --- 166 166 + Body`; 167 167 + 168 168 + const result = parseFrontmatter(content); 169 169 + expect(result.frontmatter.publishDate).toBe("2024-03-20"); 170 170 + }); 171 171 + 172 172 + test("falls back to pubDate", () => { 173 173 + const content = `--- 174 174 + title: Post 175 175 + pubDate: 2024-04-10 176 176 + --- 177 177 + Body`; 178 178 + 179 179 + const result = parseFrontmatter(content); 180 180 + expect(result.frontmatter.publishDate).toBe("2024-04-10"); 181 181 + }); 182 182 + 183 183 + test("preserves atUri field", () => { 184 184 + const content = `--- 185 185 + title: Post 186 186 + atUri: at://did:plc:abc/site.standard.post/123 187 187 + --- 188 188 + Body`; 189 189 + 190 190 + const result = parseFrontmatter(content); 191 191 + expect(result.frontmatter.atUri).toBe( 192 192 + "at://did:plc:abc/site.standard.post/123", 193 193 + ); 194 194 + }); 195 195 + 196 196 + test("maps draft field correctly", () => { 197 197 + const content = `--- 198 198 + title: Post 199 199 + draft: true 200 200 + --- 201 201 + Body`; 202 202 + 203 203 + const result = parseFrontmatter(content); 204 204 + expect(result.frontmatter.draft).toBe(true); 205 205 + }); 206 206 + }); 207 207 + 208 208 + describe("getSlugFromFilename", () => { 209 209 + test("removes .md extension", () => { 210 210 + expect(getSlugFromFilename("my-post.md")).toBe("my-post"); 211 211 + }); 212 212 + 213 213 + test("removes .mdx extension", () => { 214 214 + expect(getSlugFromFilename("my-post.mdx")).toBe("my-post"); 215 215 + }); 216 216 + 217 217 + test("converts to lowercase", () => { 218 218 + expect(getSlugFromFilename("My-Post.md")).toBe("my-post"); 219 219 + }); 220 220 + 221 221 + test("replaces spaces with dashes", () => { 222 222 + expect(getSlugFromFilename("my cool post.md")).toBe("my-cool-post"); 223 223 + }); 224 224 + }); 225 225 + 226 226 + describe("getSlugFromOptions", () => { 227 227 + test("uses filepath by default", () => { 228 228 + const slug = getSlugFromOptions("blog/my-post.md", {}); 229 229 + expect(slug).toBe("blog/my-post"); 230 230 + }); 231 231 + 232 232 + test("uses slugField from frontmatter when set", () => { 233 233 + const slug = getSlugFromOptions( 234 234 + "blog/my-post.md", 235 235 + { slug: "/custom-slug" }, 236 236 + { slugField: "slug" }, 237 237 + ); 238 238 + expect(slug).toBe("custom-slug"); 239 239 + }); 240 240 + 241 241 + test("falls back to filepath when slugField not found in frontmatter", () => { 242 242 + const slug = getSlugFromOptions("blog/my-post.md", {}, { slugField: "slug" }); 243 243 + expect(slug).toBe("blog/my-post"); 244 244 + }); 245 245 + 246 246 + test("removes /index suffix when removeIndexFromSlug is true", () => { 247 247 + const slug = getSlugFromOptions( 248 248 + "blog/my-post/index.md", 249 249 + {}, 250 250 + { removeIndexFromSlug: true }, 251 251 + ); 252 252 + expect(slug).toBe("blog/my-post"); 253 253 + }); 254 254 + 255 255 + test("removes /_index suffix when removeIndexFromSlug is true", () => { 256 256 + const slug = getSlugFromOptions( 257 257 + "blog/my-post/_index.md", 258 258 + {}, 259 259 + { removeIndexFromSlug: true }, 260 260 + ); 261 261 + expect(slug).toBe("blog/my-post"); 262 262 + }); 263 263 + 264 264 + test("strips date prefix when stripDatePrefix is true", () => { 265 265 + const slug = getSlugFromOptions( 266 266 + "2024-01-15-my-post.md", 267 267 + {}, 268 268 + { stripDatePrefix: true }, 269 269 + ); 270 270 + expect(slug).toBe("my-post"); 271 271 + }); 272 272 + 273 273 + test("strips date prefix in nested paths", () => { 274 274 + const slug = getSlugFromOptions( 275 275 + "blog/2024-01-15-my-post.md", 276 276 + {}, 277 277 + { stripDatePrefix: true }, 278 278 + ); 279 279 + expect(slug).toBe("blog/my-post"); 280 280 + }); 281 281 + 282 282 + test("combines removeIndexFromSlug and stripDatePrefix", () => { 283 283 + const slug = getSlugFromOptions( 284 284 + "blog/2024-01-15-my-post/index.md", 285 285 + {}, 286 286 + { removeIndexFromSlug: true, stripDatePrefix: true }, 287 287 + ); 288 288 + expect(slug).toBe("blog/my-post"); 289 289 + }); 290 290 + 291 291 + test("lowercases and replaces spaces", () => { 292 292 + const slug = getSlugFromOptions("Blog/My Post.md", {}); 293 293 + expect(slug).toBe("blog/my-post"); 294 294 + }); 295 295 + }); 296 296 + 297 297 + describe("getContentHash", () => { 298 298 + test("returns a hex string", async () => { 299 299 + const hash = await getContentHash("hello"); 300 300 + expect(hash).toMatch(/^[0-9a-f]+$/); 301 301 + }); 302 302 + 303 303 + test("returns consistent results", async () => { 304 304 + const hash1 = await getContentHash("test content"); 305 305 + const hash2 = await getContentHash("test content"); 306 306 + expect(hash1).toBe(hash2); 307 307 + }); 308 308 + 309 309 + test("returns different hashes for different content", async () => { 310 310 + const hash1 = await getContentHash("content a"); 311 311 + const hash2 = await getContentHash("content b"); 312 312 + expect(hash1).not.toBe(hash2); 313 313 + }); 314 314 + }); 315 315 + 316 316 + describe("updateFrontmatterWithAtUri", () => { 317 317 + test("inserts atUri into YAML frontmatter", () => { 318 318 + const content = `--- 319 319 + title: My Post 320 320 + --- 321 321 + Body`; 322 322 + 323 323 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 324 324 + expect(result).toContain('atUri: "at://did:plc:abc/post/123"'); 325 325 + expect(result).toContain("title: My Post"); 326 326 + }); 327 327 + 328 328 + test("inserts atUri into TOML frontmatter", () => { 329 329 + const content = `+++ 330 330 + title = My Post 331 331 + +++ 332 332 + Body`; 333 333 + 334 334 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 335 335 + expect(result).toContain('atUri = "at://did:plc:abc/post/123"'); 336 336 + }); 337 337 + 338 338 + test("creates frontmatter with atUri when none exists", () => { 339 339 + const content = "# My Post\n\nSome body text"; 340 340 + 341 341 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 342 342 + expect(result).toContain('atUri: "at://did:plc:abc/post/123"'); 343 343 + expect(result).toContain("---"); 344 344 + expect(result).toContain("# My Post\n\nSome body text"); 345 345 + }); 346 346 + 347 347 + test("replaces existing atUri in YAML", () => { 348 348 + const content = `--- 349 349 + title: My Post 350 350 + atUri: "at://did:plc:old/post/000" 351 351 + --- 352 352 + Body`; 353 353 + 354 354 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999"); 355 355 + expect(result).toContain('atUri: "at://did:plc:new/post/999"'); 356 356 + expect(result).not.toContain("old"); 357 357 + }); 358 358 + 359 359 + test("replaces existing atUri in TOML", () => { 360 360 + const content = `+++ 361 361 + title = My Post 362 362 + atUri = "at://did:plc:old/post/000" 363 363 + +++ 364 364 + Body`; 365 365 + 366 366 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999"); 367 367 + expect(result).toContain('atUri = "at://did:plc:new/post/999"'); 368 368 + expect(result).not.toContain("old"); 369 369 + }); 370 370 + }); 371 371 + 372 372 + describe("stripMarkdownForText", () => { 373 373 + test("removes headings", () => { 374 374 + expect(stripMarkdownForText("## Hello")).toBe("Hello"); 375 375 + }); 376 376 + 377 377 + test("removes bold", () => { 378 378 + expect(stripMarkdownForText("**bold text**")).toBe("bold text"); 379 379 + }); 380 380 + 381 381 + test("removes italic", () => { 382 382 + expect(stripMarkdownForText("*italic text*")).toBe("italic text"); 383 383 + }); 384 384 + 385 385 + test("removes links but keeps text", () => { 386 386 + expect(stripMarkdownForText("[click here](https://example.com)")).toBe( 387 387 + "click here", 388 388 + ); 389 389 + }); 390 390 + 391 391 + test("removes images", () => { 392 392 + // Note: link regex runs before image regex, so  partially matches as a link first 393 393 + expect(stripMarkdownForText("text  more")).toBe( 394 394 + "text !alt more", 395 395 + ); 396 396 + }); 397 397 + 398 398 + test("removes code blocks", () => { 399 399 + const input = "Before\n```js\nconst x = 1;\n```\nAfter"; 400 400 + expect(stripMarkdownForText(input)).toContain("Before"); 401 401 + expect(stripMarkdownForText(input)).toContain("After"); 402 402 + expect(stripMarkdownForText(input)).not.toContain("const x"); 403 403 + }); 404 404 + 405 405 + test("removes inline code formatting", () => { 406 406 + expect(stripMarkdownForText("use `npm install`")).toBe("use npm install"); 407 407 + }); 408 408 + 409 409 + test("normalizes multiple newlines", () => { 410 410 + const input = "Line 1\n\n\n\n\nLine 2"; 411 411 + expect(stripMarkdownForText(input)).toBe("Line 1\n\nLine 2"); 412 412 + }); 413 413 + }); 414 414 + 415 415 + describe("getTextContent", () => { 416 416 + test("uses textContentField from frontmatter when specified", () => { 417 417 + const post = { 418 418 + content: "# Markdown body", 419 419 + rawFrontmatter: { excerpt: "Custom excerpt text" }, 420 420 + }; 421 421 + expect(getTextContent(post, "excerpt")).toBe("Custom excerpt text"); 422 422 + }); 423 423 + 424 424 + test("falls back to stripped markdown when textContentField not found", () => { 425 425 + const post = { 426 426 + content: "**Bold text** and [a link](url)", 427 427 + rawFrontmatter: {}, 428 428 + }; 429 429 + expect(getTextContent(post, "missing")).toBe("Bold text and a link"); 430 430 + }); 431 431 + 432 432 + test("falls back to stripped markdown when no textContentField specified", () => { 433 433 + const post = { 434 434 + content: "## Heading\n\nParagraph", 435 435 + rawFrontmatter: {}, 436 436 + }; 437 437 + expect(getTextContent(post)).toBe("Heading\n\nParagraph"); 438 438 + }); 439 439 + });

+31 -1

packages/cli/src/lib/markdown.ts

··· 1 1 + import { webcrypto as crypto } from "node:crypto"; 1 2 import * as fs from "node:fs/promises"; 2 3 import * as path from "node:path"; 3 4 import { glob } from "glob"; ··· 20 21 const match = content.match(frontmatterRegex); 21 22 22 23 if (!match) { 23 23 - throw new Error("Could not parse frontmatter"); 24 24 + const [, titleMatch] = content.trim().match(/^# (.+)$/m) || [] 25 25 + const title = titleMatch ?? "" 26 26 + const [publishDate] = new Date().toISOString().split("T") 27 27 + 28 28 + return { 29 29 + frontmatter: { 30 30 + title, 31 31 + publishDate: publishDate ?? "" 32 32 + }, 33 33 + body: content, 34 34 + rawFrontmatter: { 35 35 + title: 36 36 + publishDate 37 37 + } 38 38 + } 24 39 } 25 40 26 41 const delimiter = match[1]; ··· 353 368 // Format the atUri entry based on frontmatter type 354 369 const atUriEntry = isToml ? `atUri = "${atUri}"` : `atUri: "${atUri}"`; 355 370 371 371 + // No frontmatter: create one with atUri 372 372 + if (!delimiterMatch) { 373 373 + return `---\n${atUriEntry}\n---\n\n${rawContent}`; 374 374 + } 375 375 + 356 376 // Check if atUri already exists in frontmatter (handle both formats) 357 377 if (rawContent.includes("atUri:") || rawContent.includes("atUri =")) { 358 378 // Replace existing atUri (match both YAML and TOML formats) ··· 386 406 .replace(/\n{3,}/g, "\n\n") // Normalize multiple newlines 387 407 .trim(); 388 408 } 409 409 + 410 410 + export function getTextContent( 411 411 + post: { content: string; rawFrontmatter?: Record<string, unknown> }, 412 412 + textContentField?: string, 413 413 + ): string { 414 414 + if (textContentField && post.rawFrontmatter?.[textContentField]) { 415 415 + return String(post.rawFrontmatter[textContentField]); 416 416 + } 417 417 + return stripMarkdownForText(post.content); 418 418 + }