openalmanac 0.2.56 → 0.2.58

package/dist/validate.js

@@ -1,8 +1,132 @@
 import { parse as parseYaml } from "yaml";
-const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-const KEY_RE = /^[a-z0-9]+-[a-z0-9]+(-[a-z0-9]+)*$/;
-const CITE_RE = /\[@([a-z0-9]+-[a-z0-9]+(?:-[a-z0-9]+)*)\]/g;
+import { z, ZodError } from "zod";
+// ── Primitives ──────────────────────────────────────────────────
+const sourceKeyRe = /^[a-z0-9]+-[a-z0-9]+(-[a-z0-9]+)*$/;
+// Match pydantic's `date` coercion: a bare YYYY-MM-DD date, OR any ISO-8601
+// datetime prefix — pydantic accepts "2026-04-17T00:00:00Z" as a date. yaml
+// may deserialize either as a `Date` object or a string.
+const isoDateLikeRe = /^\d{4}-\d{2}-\d{2}([T ].*)?$/;
+const accessedDateSchema = z.union([
+    z.date(),
+    z.string().regex(isoDateLikeRe, "Must be YYYY-MM-DD (optionally with an ISO time suffix)"),
+]);
+// ── Source — mirrors backend/src/schemas/source_schemas.py ──────
+export const sourceSchema = z.object({
+    key: z
+        .string()
+        .min(3)
+        .regex(sourceKeyRe, "Must be kebab-case with at least one hyphen (e.g. 'nytimes-climate-report')"),
+    url: z
+        .string()
+        .min(1)
+        .regex(/^https?:\/\//, "Must start with http:// or https://"),
+    title: z.string().min(1).max(500),
+    accessed_date: accessedDateSchema,
+}).strict();
+// ── Infobox — mirrors backend/src/schemas/infobox_schemas.py ────
+const keyValueItemSchema = z.object({
+    key: z.string(),
+    value: z.string(),
+}).strict();
+const headerBlockSchema = z.object({
+    image_url: z.string().nullable().optional(),
+    subtitle: z.string().nullable().optional(),
+    details: z.array(keyValueItemSchema).default([]),
+    // STRICTLY list[str] — no {url, label} objects. For labeled links use a
+    // `list` section with ListItem.link.
+    links: z.array(z.string()).default([]),
+}).strict();
+// Matches `default_factory=HeaderBlock` on the pydantic model. A factory
+// (not a literal) so each default produces a fresh object — preventing
+// shared-reference aliasing if a caller mutates the default.
+const emptyHeader = () => ({ details: [], links: [] });
+const timelineItemSchema = z.object({
+    primary: z.string(),
+    secondary: z.string().nullable().optional(),
+    period: z.string().nullable().optional(),
+    location: z.string().nullable().optional(),
+    description: z.array(z.string()).nullable().optional(),
+    link: z.string().nullable().optional(),
+}).strict();
+const listItemSchema = z.object({
+    title: z.string(),
+    subtitle: z.string().nullable().optional(),
+    year: z.string().nullable().optional(),
+    description: z.array(z.string()).nullable().optional(),
+    link: z.string().nullable().optional(),
+}).strict();
+const gridItemSchema = z.object({
+    title: z.string(),
+    image_url: z.string().nullable().optional(),
+    year: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    link: z.string().nullable().optional(),
+    type: z.string().nullable().optional(),
+}).strict();
+const tableRowSchema = z.object({
+    cells: z.array(z.string()),
+}).strict();
+const tableDataSchema = z.object({
+    headers: z.array(z.string()).min(1, "Table headers must be non-empty"),
+    rows: z.array(tableRowSchema),
+}).strict();
+const timelineSectionSchema = z.object({
+    type: z.literal("timeline"),
+    title: z.string(),
+    items: z.array(timelineItemSchema),
+}).strict();
+const listSectionSchema = z.object({
+    type: z.literal("list"),
+    title: z.string(),
+    items: z.array(listItemSchema),
+}).strict();
+const tagsSectionSchema = z.object({
+    type: z.literal("tags"),
+    title: z.string(),
+    items: z.array(z.string()),
+}).strict();
+const gridSectionSchema = z.object({
+    type: z.literal("grid"),
+    title: z.string(),
+    items: z.array(gridItemSchema),
+}).strict();
+const tableSectionSchema = z.object({
+    type: z.literal("table"),
+    title: z.string(),
+    items: tableDataSchema,
+}).strict();
+const keyValueSectionSchema = z.object({
+    type: z.literal("key_value"),
+    title: z.string(),
+    items: z.array(keyValueItemSchema),
+}).strict();
+const sectionSchema = z.discriminatedUnion("type", [
+    timelineSectionSchema,
+    listSectionSchema,
+    tagsSectionSchema,
+    gridSectionSchema,
+    tableSectionSchema,
+    keyValueSectionSchema,
+]);
+export const infoboxSchema = z.object({
+    header: headerBlockSchema.default(emptyHeader),
+    sections: z.array(sectionSchema).default([]),
+}).strict();
+// ── Frontmatter — mirrors backend PagePublishFrontmatter ────────
+export const pagePublishFrontmatterSchema = z.object({
+    title: z.string().min(1).max(500),
+    topics: z.array(z.string()).default([]),
+    sources: z.array(sourceSchema).default([]),
+    infobox: infoboxSchema.nullable().optional(),
+    // Informational round-trip field — `_serialize_page` embeds the wiki slug
+    // in downloaded frontmatter so agents know what they're editing. Backend
+    // ignores it at publish (wiki is taken from the URL param).
+    wiki: z.string().nullable().optional(),
+    edit_summary: z.string().nullable().optional(),
+    change_title: z.string().nullable().optional(),
+    change_description: z.string().nullable().optional(),
+}).strict();
+// ── Public surface ──────────────────────────────────────────────
 export function parseFrontmatter(raw) {
     const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
     if (!match) {
@@ -11,117 +135,20 @@ export function parseFrontmatter(raw) {
     const frontmatter = parseYaml(match[1]);
     return { frontmatter, content: match[2] };
 }
+function zodIssueToError(issue) {
+    const path = issue.path.length === 0 ? "(root)" : issue.path.join(".");
+    return { field: path, message: issue.message };
+}
 export function validateArticle(raw) {
-    const errors = [];
-    const { frontmatter, content } = parseFrontmatter(raw);
-    // content
-    if (!content || content.trim().length === 0) {
-        errors.push({ field: "content", message: "Article content is required" });
-    }
-    // title
-    const title = frontmatter.title;
-    if (!title || typeof title !== "string" || title.trim().length === 0) {
-        errors.push({ field: "title", message: "Title is required" });
-    }
-    else if (title.length > 500) {
-        errors.push({ field: "title", message: "Title must be 500 characters or fewer" });
+    const { frontmatter } = parseFrontmatter(raw);
+    try {
+        pagePublishFrontmatterSchema.parse(frontmatter);
+        return [];
     }
-    // wiki (informational, not identity)
-    const wiki = frontmatter.wiki;
-    if (wiki != null && (typeof wiki !== "string" || !SLUG_RE.test(wiki))) {
-        errors.push({
-            field: "wiki",
-            message: "Must be kebab-case (e.g. 'lockpicking')",
-        });
-    }
-    const topics = frontmatter.topics;
-    if (topics != null) {
-        if (!Array.isArray(topics)) {
-            errors.push({ field: "topics", message: "Topics must be an array of kebab-case slugs" });
-        }
-        else {
-            for (let i = 0; i < topics.length; i++) {
-                const topic = topics[i];
-                if (typeof topic !== "string" || !SLUG_RE.test(topic)) {
-                    errors.push({
-                        field: `topics[${i}]`,
-                        message: "Must be kebab-case (e.g. 'spool-pins')",
-                    });
-                }
-            }
-        }
-    }
-    // sources
-    const sources = frontmatter.sources;
-    if (!Array.isArray(sources)) {
-        errors.push({ field: "sources", message: "Sources must be an array" });
-    }
-    else {
-        const seenKeys = new Set();
-        for (let i = 0; i < sources.length; i++) {
-            const s = sources[i];
-            // key validation
-            const key = s.key;
-            if (!key || typeof key !== "string") {
-                errors.push({ field: `sources[${i}].key`, message: "Key is required" });
-            }
-            else if (!KEY_RE.test(key)) {
-                errors.push({
-                    field: `sources[${i}].key`,
-                    message: `Key "${key}" must be kebab-case with at least one hyphen (e.g. 'nytimes-climate-report')`,
-                });
-            }
-            else if (seenKeys.has(key)) {
-                errors.push({ field: `sources[${i}].key`, message: `Duplicate key "${key}"` });
-            }
-            else {
-                seenKeys.add(key);
-            }
-            if (!s.url || typeof s.url !== "string") {
-                errors.push({ field: `sources[${i}].url`, message: "URL is required" });
-            }
-            if (!s.title || typeof s.title !== "string") {
-                errors.push({ field: `sources[${i}].title`, message: "Title is required" });
-            }
-            const accessedDate = s.accessed_date;
-            if (!accessedDate) {
-                errors.push({ field: `sources[${i}].accessed_date`, message: "Accessed date is required" });
-            }
-            else if (accessedDate instanceof Date) {
-                // YAML parsed it as a Date object — valid
-            }
-            else if (typeof accessedDate === "string" && !DATE_RE.test(accessedDate)) {
-                errors.push({ field: `sources[${i}].accessed_date`, message: "Must be YYYY-MM-DD format" });
-            }
-            else if (typeof accessedDate !== "string" && !(accessedDate instanceof Date)) {
-                errors.push({ field: `sources[${i}].accessed_date`, message: "Must be YYYY-MM-DD format" });
-            }
-        }
-        // citation markers — collect all [@key] references from content
-        const citedKeys = new Set();
-        for (const match of content.matchAll(CITE_RE)) {
-            citedKeys.add(match[1]);
-        }
-        // cross-check: every [@key] in body must have a matching source
-        for (const key of citedKeys) {
-            if (!seenKeys.has(key)) {
-                errors.push({
-                    field: "citations",
-                    message: `[@${key}] referenced in content but no source has key "${key}"`,
-                });
-            }
-        }
-        // cross-check: every source key must be referenced at least once
-        for (let i = 0; i < sources.length; i++) {
-            const s = sources[i];
-            const key = s.key;
-            if (key && typeof key === "string" && !citedKeys.has(key)) {
-                errors.push({
-                    field: `sources[${i}]`,
-                    message: `Source "${key}" is never referenced with [@${key}] in the content`,
-                });
-            }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return err.issues.map(zodIssueToError);
         }
+        return [{ field: "(root)", message: String(err) }];
     }
-    return errors;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openalmanac",
-  "version": "0.2.56",
+  "version": "0.2.58",
   "description": "OpenAlmanac — pull, edit, and push articles to the open knowledge base",
   "type": "module",
   "bin": {