feat: added slug templating

docs/docs/pages/config.mdx

···
 | `ignore` | `string[]` | No | - | Glob patterns for files to ignore |
 | `removeIndexFromSlug` | `boolean` | No | `false` | Remove `/index` or `/_index` suffix from slugs |
 | `stripDatePrefix` | `boolean` | No | `false` | Remove `YYYY-MM-DD-` date prefixes from slugs (Jekyll-style) |
+| `pathTemplate` | `string` | No | - | URL path template with tokens (overrides `pathPrefix` + slug) |
 | `bluesky` | `object` | No | - | Bluesky posting configuration |
 | `bluesky.enabled` | `boolean` | No | `false` | Post to Bluesky when publishing documents (also enables [comments](/comments)) |
 | `bluesky.maxAgeDays` | `number` | No | `30` | Only post documents published within this many days |
···
   "publicDir": "public",
   "outputDir": "dist",
   "pathPrefix": "/posts",
+  "pathTemplate": "/blog/{year}/{month}/{slug}",
   "publicationUri": "at://did:plc:kq6bvkw4sxof3vdinuitehn5/site.standard.publication/3mdlavhxjhm2v",
   "pdsUrl": "https://andromeda.social",
   "frontmatter": {
···
 ```
 
 This transforms `2024-01-15-my-post.md` into the slug `my-post`.
+
+### Path Template
+
+By default, the URL path for each post is `pathPrefix + "/" + slug` (e.g., `/posts/my-post`). For more control over URL structure, use `pathTemplate` with token placeholders:
+
+```json
+{
+  "pathTemplate": "/blog/{year}/{month}/{slug}"
+}
+```
+
+This would produce paths like `/blog/2024/01/my-post`.
+
+**Available tokens:**
+
+| Token | Description | Example |
+|-------|-------------|---------|
+| `{slug}` | The generated slug (from filepath or `slugField`) | `my-post` |
+| `{year}` | Four-digit publish year | `2024` |
+| `{month}` | Zero-padded publish month | `01` |
+| `{day}` | Zero-padded publish day | `15` |
+| `{title}` | Slugified post title | `my-first-post` |
+| `{field}` | Any frontmatter field value (string fields only) | - |
+
+When `pathTemplate` is set, it overrides `pathPrefix`. If `pathTemplate` is not set, the default `pathPrefix`/slug behavior is used.
 
 ### Ignoring Files
 

packages/cli/src/commands/publish.ts

···
 	scanContentDirectory,
 	getContentHash,
 	updateFrontmatterWithAtUri,
+	resolvePostPath,
 } from "../lib/markdown";
 import type { BlogPost, BlobObject, StrongRef } from "../lib/types";
 import { exitOnCancel } from "../lib/prompts";
···
 
 			let postUrl = "";
 			if (verbose) {
-				const pathPrefix = config.pathPrefix || "/posts";
-				postUrl = `\n ${config.siteUrl}${pathPrefix}/${post.slug}`;
+				const postPath = resolvePostPath(post, config.pathPrefix, config.pathTemplate);
+				postUrl = `\n ${config.siteUrl}${postPath}`;
 			}
 			log.message(
 				`  ${icon} ${post.frontmatter.title} (${reason})${bskyNote}${postUrl}`,
···
 						} else {
 							// Create Bluesky post
 							try {
-								const pathPrefix = config.pathPrefix || "/posts";
-								const canonicalUrl = `${config.siteUrl}${pathPrefix}/${post.slug}`;
+								const canonicalUrl = `${config.siteUrl}${resolvePostPath(post, config.pathPrefix, config.pathTemplate)}`;
 
 								bskyPostRef = await createBlueskyPost(agent, {
 									title: post.frontmatter.title,

packages/cli/src/commands/sync.ts

···
 	scanContentDirectory,
 	getContentHash,
 	updateFrontmatterWithAtUri,
+	resolvePostPath,
 } from "../lib/markdown";
 import { exitOnCancel } from "../lib/prompts";
 
···
 		s.stop(`Found ${localPosts.length} local posts`);
 
 		// Build a map of path -> local post for matching
-		// Document path is like /posts/my-post-slug (or custom pathPrefix)
-		const pathPrefix = config.pathPrefix || "/posts";
+		// Document path is like /posts/my-post-slug (or custom pathPrefix/pathTemplate)
 		const postsByPath = new Map<string, (typeof localPosts)[0]>();
 		for (const post of localPosts) {
-			const postPath = `${pathPrefix}/${post.slug}`;
+			const postPath = resolvePostPath(post, config.pathPrefix, config.pathTemplate);
 			postsByPath.set(postPath, post);
 		}
 

packages/cli/src/commands/update.ts

···
 			ignore: configUpdated.ignore,
 			removeIndexFromSlug: configUpdated.removeIndexFromSlug,
 			stripDatePrefix: configUpdated.stripDatePrefix,
+			pathTemplate: configUpdated.pathTemplate,
 			textContentField: configUpdated.textContentField,
 			bluesky: configUpdated.bluesky,
 		});

packages/cli/src/lib/atproto.ts

···
 import * as mimeTypes from "mime-types";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { stripMarkdownForText } from "./markdown";
+import { stripMarkdownForText, resolvePostPath } from "./markdown";
 import { getOAuthClient } from "./oauth-client";
 import type {
 	BlobObject,
···
 	config: PublisherConfig,
 	coverImage?: BlobObject,
 ): Promise<string> {
-	const pathPrefix = config.pathPrefix || "/posts";
-	const postPath = `${pathPrefix}/${post.slug}`;
+	const postPath = resolvePostPath(post, config.pathPrefix, config.pathTemplate);
 	const publishDate = new Date(post.frontmatter.publishDate);
 
 	// Determine textContent: use configured field from frontmatter, or fallback to markdown body
···
 
 	const [, , collection, rkey] = uriMatch;
 
-	const pathPrefix = config.pathPrefix || "/posts";
-	const postPath = `${pathPrefix}/${post.slug}`;
+	const postPath = resolvePostPath(post, config.pathPrefix, config.pathTemplate);
 	const publishDate = new Date(post.frontmatter.publishDate);
 
 	// Determine textContent: use configured field from frontmatter, or fallback to markdown body

packages/cli/src/lib/config.ts

···
 	ignore?: string[];
 	removeIndexFromSlug?: boolean;
 	stripDatePrefix?: boolean;
+	pathTemplate?: string;
 	textContentField?: string;
 	bluesky?: BlueskyConfig;
 }): string {
···
 
 	if (options.stripDatePrefix) {
 		config.stripDatePrefix = options.stripDatePrefix;
+	}
+
+	if (options.pathTemplate) {
+		config.pathTemplate = options.pathTemplate;
 	}
 
 	if (options.textContentField) {

packages/cli/src/lib/markdown.ts

···
 	return slug;
 }
 
+export function resolvePathTemplate(
+	template: string,
+	post: BlogPost,
+): string {
+	const publishDate = new Date(post.frontmatter.publishDate);
+	const year = String(publishDate.getFullYear());
+	const month = String(publishDate.getMonth() + 1).padStart(2, "0");
+	const day = String(publishDate.getDate()).padStart(2, "0");
+
+	const slugifiedTitle = (post.frontmatter.title || "")
+		.toLowerCase()
+		.replace(/\s+/g, "-")
+		.replace(/[^\w-]/g, "");
+
+	// Replace known tokens
+	let result = template
+		.replace(/\{slug\}/g, post.slug)
+		.replace(/\{year\}/g, year)
+		.replace(/\{month\}/g, month)
+		.replace(/\{day\}/g, day)
+		.replace(/\{title\}/g, slugifiedTitle);
+
+	// Replace any remaining {field} tokens with raw frontmatter values
+	result = result.replace(/\{(\w+)\}/g, (_match, field: string) => {
+		const value = post.rawFrontmatter[field];
+		if (value != null && typeof value === "string") {
+			return value;
+		}
+		return "";
+	});
+
+	// Ensure leading slash
+	if (!result.startsWith("/")) {
+		result = `/${result}`;
+	}
+
+	return result;
+}
+
+export function resolvePostPath(post: BlogPost, pathPrefix?: string, pathTemplate?: string): string {
+	if (pathTemplate) {
+		return resolvePathTemplate(pathTemplate, post);
+	}
+	const prefix = pathPrefix || "/posts";
+	return `${prefix}/${post.slug}`;
+}
+
 export async function getContentHash(content: string): Promise<string> {
 	const encoder = new TextEncoder();
 	const data = encoder.encode(content);

packages/cli/src/lib/types.ts

···
 	ignore?: string[]; // Glob patterns for files to ignore (e.g., ["_index.md", "**/drafts/**"])
 	removeIndexFromSlug?: boolean; // Remove "/index" or "/_index" suffix from paths (default: false)
 	stripDatePrefix?: boolean; // Remove YYYY-MM-DD- prefix from filenames (Jekyll-style, default: false)
+	pathTemplate?: string; // URL path template with tokens like {year}/{month}/{day}/{slug} (overrides pathPrefix + slug)
 	textContentField?: string; // Frontmatter field to use for textContent instead of markdown body
 	bluesky?: BlueskyConfig; // Optional Bluesky posting configuration
 	ui?: UIConfig; // Optional UI components configuration