@rimelight/cms 0.0.2 → 0.0.3

package/src/core/registry.ts

@@ -1,5 +1,3 @@
-import type { TimeOfDay, Setting, Transition } from "./types/blocks"
-
 export interface BlockDefinition {
   type: string
   label: string
@@ -60,87 +58,3 @@ BlockRegistry.register({
   description: "Code block with syntax highlighting",
   defaultProps: { code: "", language: "typescript" }
 })
-
-BlockRegistry.register({
-  type: "ScriptBlock",
-  label: "Script",
-  description: "Script block with title, synopsis, characters, and plot tracking",
-  defaultProps: {
-    title: "",
-    synopsis: "",
-    characters: [],
-    aPlot: "",
-    bPlot: "",
-    cPlot: "",
-    stinger: ""
-  },
-  allowChildren: true
-})
-
-BlockRegistry.register({
-  type: "SceneBlock",
-  label: "Scene",
-  description: "Scene block with location, time, setting, and transition",
-  defaultProps: {
-    location: "",
-    timeOfDay: "OTHER" as TimeOfDay,
-    setting: "OTHER" as Setting,
-    transition: "NONE" as Transition,
-    description: ""
-  },
-  allowChildren: true
-})
-
-BlockRegistry.register({
-  type: "DialogueBlock",
-  label: "Dialogue",
-  description: "Dialogue block with character, parenthetical, and line",
-  defaultProps: { character: "", parenthetical: "", line: "" }
-})
-
-BlockRegistry.register({
-  type: "ComponentShowcaseBlock",
-  label: "Component Showcase",
-  description: "Live component rendering with props injection and multi-framework code examples",
-  defaultProps: {
-    componentName: "",
-    componentPath: "",
-    framework: "astro",
-    defaultProps: {},
-    propsConfig: {},
-    togglingPattern: "tab-segmented",
-    codeExamples: {}
-  },
-  allowChildren: true
-})
-
-BlockRegistry.register({
-  type: "ApiDocumentationBlock",
-  label: "API Documentation",
-  description: "Automated API documentation generation for component props, slots, emits, and theme",
-  defaultProps: {
-    componentName: "",
-    sections: {
-      props: true,
-      slots: true,
-      emits: true,
-      theme: true,
-      changelog: false
-    },
-    hide: [],
-    show: []
-  }
-})
-
-BlockRegistry.register({
-  type: "LivePreviewBlock",
-  label: "Live Preview",
-  description: "Runtime code execution with live editing and error handling",
-  defaultProps: {
-    componentCode: "",
-    framework: "astro",
-    height: "300px",
-    width: "100%",
-    editable: false
-  }
-})

package/src/core/types/blocks.ts

@@ -120,10 +120,15 @@ export interface CalloutBlockProps {
   children: BaseBlock[]
 }
 
+import type { MediaValue } from "./media"
+
 export interface ImageBlockProps {
-  src: string
+  src: string | MediaValue
   alt: string
   caption?: string
+  width?: number
+  height?: number
+  aspectRatio?: string
 }
 
 export interface CodeBlockProps {

package/src/core/types/bylines.ts

@@ -0,0 +1,14 @@
+export type BylineRole =
+  | "written_by"
+  | "reviewed_by"
+  | "edited_by"
+  | "illustrated_by"
+  | "translated_by"
+  | "curated_by"
+
+export interface BylineCredit {
+  userId: string
+  role: BylineRole
+  customTitle?: string
+  displayOrder?: number
+}

package/src/core/types/media.ts

@@ -0,0 +1,13 @@
+export interface MediaValue {
+  id: string
+  src: string
+  alt: string
+  width?: number
+  height?: number
+  format?: string
+  size?: number
+  blurhash?: string
+  previewUrl?: string
+  provider: "r2" | "external" | "local"
+  meta?: Record<string, unknown>
+}

package/src/core/types/taxonomies.ts

@@ -0,0 +1,20 @@
+import type { Localized } from "./pages"
+
+export interface TaxonomyTerm {
+  id: string
+  taxonomy: string
+  slug: string
+  label: Localized | string
+  description?: Localized | string | null
+  parentId?: string | null
+  displayOrder?: number
+  children?: TaxonomyTerm[]
+  count?: number
+  createdAt?: Date
+  updatedAt?: Date
+}
+
+export interface TaxonomyQueryOptions {
+  includeCounts?: boolean
+  locale?: string
+}

package/src/cron/scheduled.ts

@@ -0,0 +1,57 @@
+import { and, isNotNull, isNull, lt, lte } from "drizzle-orm"
+import { pageDraftLocks } from "../schema/page_draft_locks.ts"
+import { pages } from "../schema/pages.ts"
+
+export interface CmsCronResult {
+  expiredLocksCleaned: number
+  scheduledPagesActive: number
+  timestamp: string
+}
+
+/**
+ * Handles the periodic Cloudflare Worker cron trigger (e.g. "* * * * *").
+ *
+ * - Cleans up expired page draft locks
+ * - Checks for active scheduled pages
+ */
+export async function handleCmsCron(
+  _event: any,
+  _env: any,
+  _ctx: any,
+  db: any
+): Promise<CmsCronResult> {
+  const result: CmsCronResult = {
+    expiredLocksCleaned: 0,
+    scheduledPagesActive: 0,
+    timestamp: new Date().toISOString()
+  }
+
+  if (!db) return result
+
+  try {
+    const now = new Date()
+
+    // 1. Purge expired draft edit locks
+    const deletedLocks = await db
+      .delete(pageDraftLocks)
+      .where(lt(pageDraftLocks.expiresAt, now))
+      .returning({ pageId: pageDraftLocks.pageId })
+
+    result.expiredLocksCleaned = deletedLocks.length
+
+    // 2. Query active published pages in current window
+    const activeScheduled = await db
+      .select({ id: pages.id, slug: pages.slug })
+      .from(pages)
+      .where(
+        and(isNull(pages.deletedAt), isNotNull(pages.publishedVersionId), lte(pages.postedAt, now))
+      )
+      .limit(10)
+
+    result.scheduledPagesActive = activeScheduled.length
+  } catch (error) {
+    console.error("[CmsCron] Error executing scheduled tasks:", error)
+  }
+
+  return result
+}

package/src/docs/agent.ts

@@ -0,0 +1,116 @@
+import { blocksToMarkdown } from "../markdown/index.ts"
+import { pages } from "../schema/pages.ts"
+import { eq, and, isNull, isNotNull } from "drizzle-orm"
+
+export interface AgentMarkdownOptions {
+  siteUrl?: string
+  llmsUrl?: string
+  sourceUrl?: string
+}
+
+function resolveLocalized(val: unknown, locale: string = "en"): string {
+  if (!val) return ""
+  if (typeof val === "string") return val
+  if (typeof val === "object" && val !== null) {
+    const rec = val as Record<string, string>
+    return rec[locale] || rec.en || Object.values(rec)[0] || ""
+  }
+  return typeof val === "number" ? String(val) : ""
+}
+
+/**
+ * Renders a CMS page record into clean, agent-ready Markdown with YAML frontmatter.
+ */
+export function renderPageAsMarkdown(
+  page: any,
+  locale: string = "en",
+  options: AgentMarkdownOptions = {}
+): string {
+  const { siteUrl = "https://rimelight.com", llmsUrl = "/llms.txt", sourceUrl } = options
+
+  let contentObj = page.content
+  if (typeof contentObj === "string") {
+    try {
+      contentObj = JSON.parse(contentObj)
+    } catch {
+      contentObj = { blocks: [], properties: {} }
+    }
+  } else if (!contentObj || typeof contentObj !== "object") {
+    contentObj = { blocks: [], properties: {} }
+  }
+
+  const blocks = Array.isArray(contentObj.blocks) ? contentObj.blocks : []
+  const properties = contentObj.properties || {}
+
+  const title = resolveLocalized(page.title, locale) || properties.title || "Untitled"
+  const description = resolveLocalized(page.description, locale) || properties.description || ""
+  const version = properties.version || page.templateVersion
+  const markdownBody = blocksToMarkdown(blocks)
+
+  const frontmatter = [
+    "---",
+    `title: ${JSON.stringify(title)}`,
+    ...(description ? [`description: ${JSON.stringify(description)}`] : []),
+    ...(version ? [`version: ${JSON.stringify(version)}`] : []),
+    ...(page.type ? [`type: ${JSON.stringify(page.type)}`] : []),
+    "---",
+    "",
+    "> Documentation Index",
+    `> Fetch the complete documentation index at: ${new URL(llmsUrl, siteUrl).href}`,
+    "> Use this file to discover all available pages and sections.",
+    "",
+    `# ${title}`,
+    "",
+    markdownBody,
+    ""
+  ]
+
+  if (sourceUrl) {
+    frontmatter.push(`Source: ${new URL(sourceUrl, siteUrl).href}`, "")
+  }
+
+  return frontmatter.join("\n")
+}
+
+/**
+ * Collate all published pages of a given type into a single corpus markdown document.
+ */
+export async function renderCorpusMarkdown(
+  db: any,
+  options: {
+    type?: string
+    locale?: string
+    siteUrl?: string
+    title?: string
+    description?: string
+  } = {}
+): Promise<string> {
+  const {
+    type = "doc",
+    locale = "en",
+    siteUrl = "https://rimelight.com",
+    title = "Rimelight Documentation Corpus",
+    description = "Complete single-corpus documentation for AI agents."
+  } = options
+
+  if (!db) return `# ${title}\n\n${description}`
+
+  const conditions = [isNull(pages.deletedAt), isNotNull(pages.publishedVersionId)]
+  if (type) {
+    conditions.push(eq(pages.type, type))
+  }
+
+  const rows = await db
+    .select()
+    .from(pages)
+    .where(and(...conditions))
+
+  const parts = [`# ${title}`, "", description, "", `Generated for site: ${siteUrl}`, "", "---", ""]
+
+  for (const page of rows) {
+    const pageMd = renderPageAsMarkdown(page, locale, { siteUrl })
+    parts.push(pageMd, "", "---", "")
+  }
+
+  return parts.join("\n")
+}

package/src/docs/config.ts

@@ -0,0 +1,25 @@
+import type { SidebarItem, SidebarScope } from "@rimelight/ui/components/sidebar/sidebar.ts"
+import type { BadgeProps } from "@rimelight/ui/components/badge/badge.ts"
+
+export interface EditLinkConfig {
+  baseUrl: string
+}
+
+export interface TableOfContentsConfig {
+  minHeadingLevel?: number
+  maxHeadingLevel?: number
+}
+
+export interface DocsConfig {
+  basePath?: string
+  sidebar:
+    | (SidebarItem | SidebarScope)[]
+    | {
+        scopes: SidebarScope[]
+      }
+  editLink?: EditLinkConfig
+  tableOfContents?: false | TableOfContentsConfig
+}
+
+export const defineDocsConfig = <const T extends DocsConfig>(config: T): T => config
+export type { BadgeProps, SidebarItem, SidebarScope }

package/src/docs/index.ts

@@ -0,0 +1,5 @@
+export * from "./config.ts"
+export * from "./sidebar.ts"
+export * from "./routing.ts"
+export * from "./toc.ts"
+export * from "./agent.ts"

package/src/docs/routing.ts

@@ -0,0 +1,104 @@
+export interface DocEntry {
+  id?: string
+  slug?: string
+  version?: string
+  properties?: Record<string, any>
+  [key: string]: any
+}
+
+export function getDocsVersions(entries: (DocEntry | string)[], locale?: string): string[] {
+  const versions = new Set<string>()
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      const parts = entry.replace(/\\/g, "/").split("/")
+      if (parts[0]?.startsWith("v")) {
+        versions.add(parts[0])
+      }
+      continue
+    }
+
+    if (entry.version && entry.version.startsWith("v")) {
+      versions.add(entry.version)
+      continue
+    }
+
+    if (entry.properties?.version && String(entry.properties.version).startsWith("v")) {
+      versions.add(String(entry.properties.version))
+      continue
+    }
+
+    const path = (entry.slug || entry.id || "").replace(/\\/g, "/")
+    const parts = path.split("/")
+    if (locale && parts[1] === locale && parts[0]?.startsWith("v")) {
+      versions.add(parts[0])
+    } else if (parts[0]?.startsWith("v")) {
+      versions.add(parts[0])
+    }
+  }
+  return Array.from(versions).toSorted((a, b) => {
+    return b.localeCompare(a, undefined, { numeric: true, sensitivity: "base" })
+  })
+}
+
+export function parseDocsSlug(slug: string | undefined, versions: string[]) {
+  if (versions.length === 0) {
+    return {
+      activeVersion: "",
+      contentPath: slug || "index",
+      includeVersionInUrl: false
+    }
+  }
+
+  const defaultVersion = versions[0]
+  const isMultiVersion = versions.length > 1
+
+  if (!slug) {
+    return {
+      activeVersion: defaultVersion,
+      contentPath: "index",
+      includeVersionInUrl: isMultiVersion
+    }
+  }
+
+  const parts = slug.split("/")
+  const firstPart = parts[0]
+
+  if (firstPart && versions.includes(firstPart)) {
+    return {
+      activeVersion: firstPart,
+      contentPath: parts.slice(1).join("/") || "index",
+      includeVersionInUrl: isMultiVersion
+    }
+  }
+
+  return {
+    activeVersion: defaultVersion,
+    contentPath: slug || "index",
+    includeVersionInUrl: isMultiVersion
+  }
+}
+
+export function formatDocsUrl(
+  href: string,
+  locale: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): string {
+  let url = href.replace("{locale}", locale)
+  if (activeVersion && includeVersionInUrl) {
+    if (url.includes(`/${activeVersion}/`) || url.endsWith(`/${activeVersion}`)) {
+      return url
+    }
+    const docsPattern = new RegExp(`(/${locale}/docs)(/|$)`)
+    const companyDocsPattern = new RegExp(`(/${locale}/company/docs)(/|$)`)
+
+    if (companyDocsPattern.test(url)) {
+      url = url.replace(companyDocsPattern, `$1/${activeVersion}$2`)
+    } else if (docsPattern.test(url)) {
+      url = url.replace(docsPattern, `$1/${activeVersion}$2`)
+    }
+
+    url = url.replace(/\/{2,}/g, "/")
+  }
+  return url
+}