@nickmeriano/task 0.4.2 → 0.6.0

package/src/store.ts

@@ -1,5 +1,5 @@
 import { DatabaseSync } from "node:sqlite"
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, readdirSync, readFileSync } from "node:fs"
 import { dirname, join, relative, sep } from "node:path"
 import type {
   Comment,
@@ -9,14 +9,43 @@ import type {
   TaskFilter,
   TaskInput,
   TaskPatch,
-} from "./types.js"
+} from "./types.ts"
 
 export const TASK_DIR = ".task"
 export const DB_FILE = "tasks.db"
 export const CONFIG_FILE = "config.json"
 
 /** Spacing between adjacent board positions — leaves room to drop between. */
-const POSITION_GAP = 1024
+export const POSITION_GAP = 1024
+
+/**
+ * What a board's persistence layer looks like, whichever representation backs
+ * it. Two implementations: `FileStore` (text files in `.task/tickets/`, the
+ * canonical format) and the legacy `TaskStore` (a committed SQLite database),
+ * which survives so un-migrated boards keep working. `openBoard` picks.
+ */
+export interface Store {
+  readonly root: string
+  readonly taskDir: string
+  readonly config: ProjectConfig
+  close(): void
+  displayId(number: number): string
+  parseId(ref: string): number
+  list(filter?: TaskFilter): Task[]
+  get(number: number): Task | null
+  create(input: TaskInput): Task
+  update(number: number, patch: TaskPatch): Task
+  link(number: number, relation: "blocks" | "blocked_by", target: number): Task
+  unlink(number: number, relation: "blocks" | "blocked_by", target: number): Task
+  delete(number: number): void
+  /** Move a done/canceled ticket to `.task/archive/`, out of the board's hot path. */
+  archive(number: number): Task
+  unarchive(number: number): Task
+  comments(number: number): Comment[]
+  addComment(number: number, body: string, author?: string): Comment
+  deleteComment(number: number, commentId: string): Comment
+  commentCounts(): Map<number, number>
+}
 
 /**
  * Walk up from `from` looking for a `.task/config.json`, the way git finds its
@@ -39,6 +68,46 @@ export interface BoardRef {
   root: string
 }
 
+/**
+ * The widest board scope `from` belongs to: the *outermost* ancestor holding a
+ * `.task/` (a monorepo's root board), or `from` itself when no ancestor has
+ * one. Where `findRoot` answers "which board am I on", this answers "which
+ * repo of boards am I in" — the anchor for anything cross-board: prefix
+ * routing and `task boards`.
+ */
+export function findScopeRoot(from: string): string {
+  let dir = from
+  let top: string | null = null
+  for (;;) {
+    if (existsSync(join(dir, TASK_DIR, CONFIG_FILE))) top = dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return top ?? from
+}
+
+/** A board's config, read without opening a store. Throws on a broken file. */
+export function boardConfig(root: string): ProjectConfig {
+  return JSON.parse(readFileSync(join(root, TASK_DIR, CONFIG_FILE), "utf8")) as ProjectConfig
+}
+
+/**
+ * Every board in scope whose prefix is `prefix` (case-insensitive). Normally
+ * zero or one — two boards sharing a prefix is a repo mistake this surfaces
+ * rather than resolves. Boards with unreadable configs can't match.
+ */
+export function findBoardsByPrefix(scopeRoot: string, prefix: string): BoardRef[] {
+  const wanted = prefix.toUpperCase()
+  return findBoards(scopeRoot).filter((ref) => {
+    try {
+      return boardConfig(ref.root).prefix.toUpperCase() === wanted
+    } catch {
+      return false
+    }
+  })
+}
+
 /** Directories that never contain a board worth serving. */
 const SKIP_DIRS = new Set(["node_modules", "dist", "build", "out", "coverage", "target"])
 
@@ -79,10 +148,10 @@ export function findBoards(serveRoot: string, maxDepth = 6): BoardRef[] {
   return boards
 }
 
-/** Derive an id prefix from a project name: "phone agent" → "PHONE". */
+/** Derive an id prefix from a project name: "phone agent" → "PHO". */
 export function derivePrefix(name: string): string {
   const word = name.toUpperCase().replace(/[^A-Z0-9]+/g, " ").trim().split(" ")[0]
-  return (word || "TASK").slice(0, 10)
+  return (word || "TAS").slice(0, 3)
 }
 
 interface TaskRow {
@@ -93,6 +162,7 @@ interface TaskRow {
   tags: string
   milestone: string | null
   needs_human: number
+  prs: string
   position: number
   created_at: string
   updated_at: string
@@ -111,11 +181,12 @@ function now(): string {
 }
 
 /**
- * The whole persistence layer: one SQLite database inside `.task/`, opened
+ * The legacy persistence layer: one SQLite database inside `.task/`, opened
  * synchronously via node:sqlite (built into Node ≥22.13 — zero dependencies,
- * nothing to compile, safe for `npx`).
+ * nothing to compile, safe for `npx`). Boards created before the text format
+ * still run on this until `task migrate` moves them over.
  */
-export class TaskStore {
+export class TaskStore implements Store {
   readonly root: string
   readonly taskDir: string
   readonly config: ProjectConfig
@@ -160,15 +231,27 @@ export class TaskStore {
       tags: JSON.parse(row.tags) as string[],
       milestone: row.milestone,
       needsHuman: row.needs_human !== 0,
+      blocks: this.linkedNumbers("blocker_id", row.id),
+      blockedBy: this.linkedNumbers("blocked_id", row.id),
+      prs: JSON.parse(row.prs) as string[],
       position: row.position,
       createdAt: row.created_at,
       updatedAt: row.updated_at,
     }
   }
 
+  /** The other end of every link where `column` is this task. */
+  private linkedNumbers(column: "blocker_id" | "blocked_id", number: number): number[] {
+    const other = column === "blocker_id" ? "blocked_id" : "blocker_id"
+    const rows = this.db
+      .prepare(`SELECT ${other} AS n FROM task_links WHERE ${column} = ? ORDER BY ${other}`)
+      .all(number) as unknown as { n: number }[]
+    return rows.map((r) => r.n)
+  }
+
   private toComment(row: CommentRow): Comment {
     return {
-      id: row.id,
+      id: String(row.id),
       taskId: this.displayId(row.task_id),
       author: row.author,
       body: row.body,
@@ -177,6 +260,9 @@ export class TaskStore {
   }
 
   list(filter: TaskFilter = {}): Task[] {
+    if (filter.archived) {
+      throw new Error("archiving needs a text-format board — run `task migrate` first")
+    }
     const where: string[] = []
     const params: (string | number)[] = []
     if (filter.statuses?.length) {
@@ -217,8 +303,8 @@ export class TaskStore {
     const timestamp = now()
     const result = this.db
       .prepare(
-        `INSERT INTO tasks (title, description, status, tags, milestone, needs_human, position, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        `INSERT INTO tasks (title, description, status, tags, milestone, needs_human, prs, position, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       )
       .run(
         input.title,
@@ -227,17 +313,31 @@ export class TaskStore {
         JSON.stringify(input.tags ?? []),
         input.milestone ?? null,
         input.needsHuman ? 1 : 0,
+        JSON.stringify(input.prs ?? []),
         (max.max ?? 0) + POSITION_GAP,
         timestamp,
         timestamp,
       )
-    return this.get(Number(result.lastInsertRowid))!
+    const number = Number(result.lastInsertRowid)
+    if (input.blocks !== undefined) this.reconcileLinks("blocker_id", number, input.blocks)
+    if (input.blockedBy !== undefined) this.reconcileLinks("blocked_id", number, input.blockedBy)
+    return this.get(number)!
   }
 
   update(number: number, patch: TaskPatch): Task {
     const existing = this.get(number)
     if (!existing) throw new Error(`no such task: ${this.displayId(number)}`)
 
+    // Reconciled outside the UPDATE — links live in their own table. Done
+    // first so a bad target rejects the whole patch before anything writes.
+    let linksChanged = false
+    if (patch.blocks !== undefined) {
+      linksChanged = this.reconcileLinks("blocker_id", number, patch.blocks)
+    }
+    if (patch.blockedBy !== undefined) {
+      linksChanged = this.reconcileLinks("blocked_id", number, patch.blockedBy) || linksChanged
+    }
+
     const sets: string[] = []
     const params: (string | number | null)[] = []
     const set = (column: string, value: string | number | null) => {
@@ -250,6 +350,7 @@ export class TaskStore {
     if (patch.tags !== undefined) set("tags", JSON.stringify(patch.tags))
     if (patch.milestone !== undefined) set("milestone", patch.milestone)
     if (patch.needsHuman !== undefined) set("needs_human", patch.needsHuman ? 1 : 0)
+    if (patch.prs !== undefined) set("prs", JSON.stringify(patch.prs))
     if (patch.status !== undefined) {
       set("status", patch.status)
       if (patch.position === undefined && patch.status !== existing.status) {
@@ -263,10 +364,73 @@ export class TaskStore {
     }
     if (patch.position !== undefined) set("position", patch.position)
 
-    if (sets.length === 0) return existing
-    set("updated_at", now())
-    params.push(number)
-    this.db.prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params)
+    if (sets.length === 0 && !linksChanged) return existing
+    if (sets.length > 0) {
+      set("updated_at", now())
+      params.push(number)
+      this.db.prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params)
+    }
+    return this.get(number)!
+  }
+
+  /**
+   * Make the link table agree with `targets` for one side of one task —
+   * `blocker_id` when setting what `number` blocks, `blocked_id` when setting
+   * what blocks it. The other task's view is the same row read from the other
+   * end, so there is no second write to keep consistent. Every task touched
+   * (both ends of every added or removed link) gets its `updated_at` bumped.
+   */
+  private reconcileLinks(
+    column: "blocker_id" | "blocked_id",
+    number: number,
+    targets: number[],
+  ): boolean {
+    const other = column === "blocker_id" ? "blocked_id" : "blocker_id"
+    const wanted = [...new Set(targets)]
+    for (const target of wanted) {
+      if (target === number) {
+        throw new Error(`a task can't block itself: ${this.displayId(number)}`)
+      }
+      if (!this.db.prepare("SELECT id FROM tasks WHERE id = ?").get(target)) {
+        throw new Error(`no such task: ${this.displayId(target)}`)
+      }
+    }
+    const current = new Set(this.linkedNumbers(column, number))
+    const removed = [...current].filter((n) => !wanted.includes(n))
+    const added = wanted.filter((n) => !current.has(n))
+    for (const n of removed) {
+      this.db
+        .prepare(`DELETE FROM task_links WHERE ${column} = ? AND ${other} = ?`)
+        .run(number, n)
+    }
+    for (const n of added) {
+      this.db
+        .prepare(`INSERT OR IGNORE INTO task_links (${column}, ${other}) VALUES (?, ?)`)
+        .run(number, n)
+    }
+    const touched = [...removed, ...added]
+    if (touched.length > 0) {
+      const timestamp = now()
+      const bump = this.db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?")
+      for (const n of [...touched, number]) bump.run(timestamp, n)
+    }
+    return touched.length > 0
+  }
+
+  /** `task link A --blocks B` and friends — additive, unlike the patch form. */
+  link(number: number, relation: "blocks" | "blocked_by", target: number): Task {
+    if (!this.get(number)) throw new Error(`no such task: ${this.displayId(number)}`)
+    const column = relation === "blocks" ? "blocker_id" : "blocked_id"
+    const current = this.linkedNumbers(column, number)
+    this.reconcileLinks(column, number, [...current, target])
+    return this.get(number)!
+  }
+
+  unlink(number: number, relation: "blocks" | "blocked_by", target: number): Task {
+    if (!this.get(number)) throw new Error(`no such task: ${this.displayId(number)}`)
+    const column = relation === "blocks" ? "blocker_id" : "blocked_id"
+    const current = this.linkedNumbers(column, number)
+    this.reconcileLinks(column, number, current.filter((n) => n !== target))
     return this.get(number)!
   }
 
@@ -275,6 +439,15 @@ export class TaskStore {
     if (result.changes === 0) throw new Error(`no such task: ${this.displayId(number)}`)
   }
 
+  /** The archive is a text-format feature — a directory move, not a table. */
+  archive(_number: number): Task {
+    throw new Error("archiving needs a text-format board — run `task migrate` first")
+  }
+
+  unarchive(_number: number): Task {
+    throw new Error("archiving needs a text-format board — run `task migrate` first")
+  }
+
   comments(number: number): Comment[] {
     const rows = this.db
       .prepare("SELECT * FROM comments WHERE task_id = ? ORDER BY id")
@@ -293,12 +466,17 @@ export class TaskStore {
     return this.toComment(row)
   }
 
-  deleteComment(number: number, commentId: number): Comment {
-    const row = this.db
-      .prepare("SELECT * FROM comments WHERE id = ? AND task_id = ?")
-      .get(commentId, number) as unknown as CommentRow | undefined
+  deleteComment(number: number, commentId: string): Comment {
+    const rowid = Number(commentId)
+    const row = (
+      Number.isInteger(rowid)
+        ? this.db
+            .prepare("SELECT * FROM comments WHERE id = ? AND task_id = ?")
+            .get(rowid, number)
+        : undefined
+    ) as CommentRow | undefined
     if (!row) throw new Error(`no such comment on ${this.displayId(number)}: ${commentId}`)
-    this.db.prepare("DELETE FROM comments WHERE id = ?").run(commentId)
+    this.db.prepare("DELETE FROM comments WHERE id = ?").run(rowid)
     return this.toComment(row)
   }
 
@@ -365,6 +543,17 @@ const MIGRATIONS: string[] = [
    ALTER TABLE tasks ADD COLUMN needs_human INTEGER NOT NULL DEFAULT 0;
    ALTER TABLE tasks DROP COLUMN priority;
    ALTER TABLE tasks DROP COLUMN assignee;`,
+
+  // v3 — dependencies and pull requests. One direction of "blocks" is the
+  // whole relation: (blocker, blocked) read from the blocked side is
+  // "blocked by", so the mirror is a query, not a second row. PRs are a JSON
+  // list of URLs, same shape as tags.
+  `CREATE TABLE task_links (
+     blocker_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+     blocked_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+     PRIMARY KEY (blocker_id, blocked_id)
+   );
+   ALTER TABLE tasks ADD COLUMN prs TEXT NOT NULL DEFAULT '[]';`,
 ]
 
 /**
@@ -388,31 +577,3 @@ function migrate(db: DatabaseSync): void {
   }
 }
 
-export interface InitOptions {
-  name: string
-  prefix?: string
-}
-
-/**
- * Create `.task/` in `root`: config, an empty database, and a .gitignore for
- * SQLite's transient sidecar files (the database itself is meant to be
- * committed — that's the point).
- */
-export function initProject(root: string, options: InitOptions): TaskStore {
-  const taskDir = join(root, TASK_DIR)
-  if (existsSync(join(taskDir, CONFIG_FILE))) {
-    throw new Error(`already initialized: ${join(taskDir, CONFIG_FILE)} exists`)
-  }
-  mkdirSync(taskDir, { recursive: true })
-  const config: ProjectConfig = {
-    name: options.name,
-    prefix: options.prefix ?? derivePrefix(options.name),
-    version: 1,
-  }
-  writeFileSync(join(taskDir, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`)
-  writeFileSync(
-    join(taskDir, ".gitignore"),
-    "# SQLite transients — tasks.db itself is committed.\n*.db-journal\n*.db-wal\n*.db-shm\n",
-  )
-  return new TaskStore(root)
-}

package/src/ticket-doc.ts

@@ -0,0 +1,226 @@
+/**
+ * The text format a board is made of: one markdown file per ticket, one per
+ * comment, each carrying a small frontmatter block. This module is pure
+ * (de)serialization — no filesystem — so the store, the migration, and the
+ * hosted board's worker can all agree on bytes by construction.
+ *
+ * The frontmatter is a deliberately tiny YAML subset: every value on one line,
+ * written either bare (timestamps, statuses) or as JSON (strings that need
+ * quoting, arrays, numbers, booleans). JSON is valid YAML, so the files render
+ * as ordinary frontmatter on GitHub while the parser stays `JSON.parse` plus a
+ * bare-string fallback — no dependency, no ambiguity.
+ *
+ * The ticket's title is the body's first `# ` heading and the description is
+ * everything after it. That keeps the whole file readable as a document — a PR
+ * diff of a new ticket *is* the ticket.
+ */
+
+import { STATUSES, isStatus, type Status } from "./types.ts"
+
+/** Everything `ticket.md` stores. Relations live on the blocked side only. */
+export interface TicketDoc {
+  title: string
+  description: string
+  status: Status
+  tags: string[]
+  milestone: string | null
+  needsHuman: boolean
+  /** Task numbers blocking this one — the single stored side of the relation. */
+  blockedBy: number[]
+  prs: string[]
+  position: number
+  createdAt: string
+  updatedAt: string
+}
+
+export interface CommentDoc {
+  author: string
+  createdAt: string
+  body: string
+}
+
+/** A parse that names the file it failed in — these files invite hand-editing. */
+export class TicketParseError extends Error {}
+
+// ── The frontmatter subset ───────────────────────────────────────────────────
+
+interface RawDoc {
+  fields: Map<string, string>
+  body: string
+}
+
+/**
+ * One scalar: JSON if it parses, the raw string otherwise. The fallback is
+ * what lets timestamps and simple strings be written bare — and what forgives
+ * a hand-edit that writes `milestone: launch` without quotes.
+ */
+function parseScalar(raw: string): unknown {
+  const trimmed = raw.trim()
+  if (trimmed === "") return ""
+  try {
+    return JSON.parse(trimmed) as unknown
+  } catch {
+    return trimmed
+  }
+}
+
+function splitRaw(text: string, where: string): RawDoc {
+  const lines = text.replace(/\r\n/g, "\n").split("\n")
+  if (lines[0] !== "---") {
+    throw new TicketParseError(`${where}: expected the file to start with a --- frontmatter block`)
+  }
+  const end = lines.indexOf("---", 1)
+  if (end < 0) {
+    throw new TicketParseError(`${where}: unterminated frontmatter — no closing ---`)
+  }
+  const fields = new Map<string, string>()
+  for (const line of lines.slice(1, end)) {
+    if (!line.trim()) continue
+    const colon = line.indexOf(":")
+    if (colon < 0) {
+      throw new TicketParseError(`${where}: not a "key: value" frontmatter line: ${line}`)
+    }
+    fields.set(line.slice(0, colon).trim(), line.slice(colon + 1))
+  }
+  const body = lines.slice(end + 1).join("\n")
+  return { fields, body: body.replace(/^\n+/, "").replace(/\s+$/, "") }
+}
+
+function field(raw: RawDoc, key: string): unknown {
+  const value = raw.fields.get(key)
+  return value === undefined ? undefined : parseScalar(value)
+}
+
+function stringField(raw: RawDoc, key: string, where: string, fallback: string): string {
+  const value = field(raw, key)
+  if (value === undefined) return fallback
+  if (typeof value === "string") return value
+  throw new TicketParseError(`${where}: ${key} should be a string`)
+}
+
+function stringList(raw: RawDoc, key: string, where: string): string[] {
+  const value = field(raw, key)
+  if (value === undefined) return []
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) return value
+  throw new TicketParseError(`${where}: ${key} should be a list of strings, e.g. ["a", "b"]`)
+}
+
+function numberList(raw: RawDoc, key: string, where: string): number[] {
+  const value = field(raw, key)
+  if (value === undefined) return []
+  if (Array.isArray(value) && value.every((v) => typeof v === "number" && Number.isInteger(v))) {
+    return value as number[]
+  }
+  throw new TicketParseError(`${where}: ${key} should be a list of task numbers, e.g. [3, 7]`)
+}
+
+// ── Tickets ──────────────────────────────────────────────────────────────────
+
+/**
+ * Title ↔ first `# ` heading. Only the very first line can be the title, so a
+ * description that itself opens with a heading round-trips unambiguously.
+ */
+function splitTitle(body: string): { title: string | null; description: string } {
+  if (!body.startsWith("# ")) return { title: null, description: body }
+  const newline = body.indexOf("\n")
+  if (newline < 0) return { title: body.slice(2).trim(), description: "" }
+  return {
+    title: body.slice(2, newline).trim(),
+    description: body.slice(newline + 1).replace(/^\n+/, ""),
+  }
+}
+
+export function parseTicket(text: string, where: string): TicketDoc {
+  const raw = splitRaw(text, where)
+  const status = stringField(raw, "status", where, "todo")
+  if (!isStatus(status)) {
+    throw new TicketParseError(
+      `${where}: invalid status "${status}" — one of: ${STATUSES.join(", ")}`,
+    )
+  }
+  const milestone = field(raw, "milestone")
+  if (milestone !== undefined && milestone !== null && typeof milestone !== "string") {
+    throw new TicketParseError(`${where}: milestone should be a string`)
+  }
+  const needsHuman = field(raw, "needs_human")
+  const position = field(raw, "position")
+  if (position !== undefined && typeof position !== "number") {
+    throw new TicketParseError(`${where}: position should be a number`)
+  }
+  const { title, description } = splitTitle(raw.body)
+  if (title === null) {
+    throw new TicketParseError(`${where}: expected the body to start with "# <title>"`)
+  }
+  return {
+    title,
+    description,
+    status,
+    tags: stringList(raw, "tags", where),
+    milestone: typeof milestone === "string" && milestone !== "" ? milestone : null,
+    needsHuman: needsHuman === true,
+    blockedBy: numberList(raw, "blocked_by", where),
+    prs: stringList(raw, "prs", where),
+    position: typeof position === "number" ? position : 0,
+    createdAt: stringField(raw, "created", where, ""),
+    updatedAt: stringField(raw, "updated", where, ""),
+  }
+}
+
+/** JSON array on one line — `["a", "b"]` — which is also valid YAML flow style. */
+function list(values: (string | number)[]): string {
+  return `[${values.map((v) => JSON.stringify(v)).join(", ")}]`
+}
+
+/**
+ * The canonical bytes for a ticket. Field order is fixed and empty fields are
+ * omitted, so an unchanged ticket always serializes identically — diffs show
+ * edits, never churn.
+ */
+export function serializeTicket(doc: TicketDoc): string {
+  const lines = ["---", `status: ${doc.status}`]
+  if (doc.tags.length) lines.push(`tags: ${list(doc.tags)}`)
+  if (doc.milestone) lines.push(`milestone: ${JSON.stringify(doc.milestone)}`)
+  if (doc.needsHuman) lines.push(`needs_human: true`)
+  if (doc.blockedBy.length) lines.push(`blocked_by: ${list(doc.blockedBy)}`)
+  if (doc.prs.length) lines.push(`prs: ${list(doc.prs)}`)
+  lines.push(`position: ${doc.position}`)
+  lines.push(`created: ${doc.createdAt}`)
+  lines.push(`updated: ${doc.updatedAt}`)
+  lines.push("---", "", `# ${doc.title}`)
+  if (doc.description) lines.push("", doc.description)
+  return `${lines.join("\n")}\n`
+}
+
+// ── Comments ─────────────────────────────────────────────────────────────────
+
+export function parseComment(text: string, where: string): CommentDoc {
+  const raw = splitRaw(text, where)
+  return {
+    author: stringField(raw, "author", where, ""),
+    createdAt: stringField(raw, "created", where, ""),
+    body: raw.body,
+  }
+}
+
+export function serializeComment(doc: CommentDoc): string {
+  const lines = ["---"]
+  if (doc.author) lines.push(`author: ${JSON.stringify(doc.author)}`)
+  lines.push(`created: ${doc.createdAt}`, "---", "", doc.body)
+  return `${lines.join("\n")}\n`
+}
+
+/**
+ * A comment's filename stem — readable, sortable, and unique enough that two
+ * branches almost never mint the same one: `2026-08-15T165943-claude`. The
+ * frontmatter stays authoritative for author and timestamp; the name is for
+ * humans scanning a directory and for the comment's stable id.
+ */
+export function commentStem(createdAt: string, author: string): string {
+  const compact = `${createdAt.slice(0, 10)}T${createdAt.slice(11, 19).replace(/:/g, "")}`
+  const slug = author
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 24)
+  return slug ? `${compact}-${slug}` : compact
+}