@o-a/cms-agent 0.1.7 → 0.2.1

package/dist/services/migration-runner.js

@@ -1,5 +1,5 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { listFilesRecursively } from "./fs-walk.js";
 import { GitOperationError, commitPaths } from "./git.js";
 import { validateContent } from "./validation.js";
@@ -41,11 +41,23 @@ function applyMigrationChain(content, migrations, currentVersion, path) {
 // Hand-rolled fs snapshot/restore, matching publish.ts's established
 // shape - but simpler: every file the write phase touches already
 // existed with real prior bytes (F3's skip logic guarantees this), so
-// there is no "did this file exist before" branch to carry.
+// there is no "did this file exist before" branch to carry. A
+// relocated file (targetPath !== path) is undone by removing whatever
+// landed at targetPath and restoring the original at its original path.
 function rollback(files) {
     const failures = [];
     for (const file of files) {
         try {
+            if (file.targetPath !== file.path) {
+                try {
+                    unlinkSync(file.targetPath);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                }
+            }
             writeFileSync(file.path, file.originalBytes);
         }
         catch (error) {
@@ -55,27 +67,42 @@ function rollback(files) {
     return failures;
 }
 async function runMigrationsJob(config, themeSchemas, migrations, currentVersion, author) {
-    // Three named walks (pages/posts/menus), not one broad walk of
+    // content/posts/ is a legacy root: posts were folded into pages, and
+    // no code walks a postsRoot for anything else any more (see
+    // config.ts) - it's computed locally, here only, purely to find any
+    // leftover legacy files this migration needs to relocate. A site
+    // that never had posts has no such directory; listFilesRecursively
+    // already returns [] for a missing root, same as every other caller.
+    const legacyPostsRoot = join(config.contentRoot, 'posts');
+    // Named walks (pages/menus/legacy posts), not one broad walk of
     // contentRoot - see content-read.ts's listContent for the identical
     // reasoning (Group N nested draftsRoot/redirectsPath inside
     // contentRoot; a broad walk would double-migrate drafts and try to
     // validate redirects.json as a page). base stays config.contentRoot
-    // for all three so relativePath matches what validateContent expects.
+    // for pages/menus so relativePath matches what validateContent
+    // expects. Legacy posts get their own targetPath: content/posts/
+    // was always flat (no nested slugs), so relocating each file to
+    // content/pages/blog/<slug>.json preserves its old /blog/<slug> URL
+    // as an ordinary nested page - no reserved namespace needed any more.
     const files = [
         ...listFilesRecursively(config.pagesRoot, config.contentRoot, '.json').map((rel) => ({
             path: join(config.contentRoot, rel),
-            relativePath: rel,
-        })),
-        ...listFilesRecursively(config.postsRoot, config.contentRoot, '.json').map((rel) => ({
-            path: join(config.contentRoot, rel),
+            targetPath: join(config.contentRoot, rel),
             relativePath: rel,
         })),
         ...listFilesRecursively(config.menusRoot, config.contentRoot, '.json').map((rel) => ({
             path: join(config.contentRoot, rel),
+            targetPath: join(config.contentRoot, rel),
             relativePath: rel,
         })),
+        ...listFilesRecursively(legacyPostsRoot, legacyPostsRoot, '.json').map((rel) => ({
+            path: join(legacyPostsRoot, rel),
+            targetPath: join(config.contentRoot, 'pages', 'blog', rel),
+            relativePath: join('pages', 'blog', rel),
+        })),
         ...listFilesRecursively(config.draftsRoot, config.draftsRoot, '.json').map((rel) => ({
             path: join(config.draftsRoot, rel),
+            targetPath: join(config.draftsRoot, rel),
             relativePath: rel,
         })),
     ];
@@ -84,10 +111,14 @@ async function runMigrationsJob(config, themeSchemas, migrations, currentVersion
     // files so far is simply discarded - a mid-list failure aborts with
     // literally zero writes having happened (F4's primary scenario).
     const toMigrate = [];
-    for (const { path, relativePath } of files) {
+    for (const { path, targetPath, relativePath } of files) {
         const originalBytes = readFileSync(path);
         const parsed = JSON.parse(originalBytes.toString('utf-8'));
         const schemaVersion = parsed.schemaVersion;
+        // A legacy posts/ file can never already be at currentVersion: the
+        // posts/ directory only ever held content written before this very
+        // migration existed, so this skip and the relocation above never
+        // conflict in practice.
         if (typeof schemaVersion === 'number' && schemaVersion >= currentVersion) {
             continue;
         }
@@ -97,16 +128,27 @@ async function runMigrationsJob(config, themeSchemas, migrations, currentVersion
             throw new MigrationError('validation-failed', `Migrated content at "${path}" failed validation: ${JSON.stringify(result.errors)}`);
         }
         const migratedBytes = Buffer.from(JSON.stringify(migrated, null, 2));
-        toMigrate.push({ path, originalBytes, migratedBytes });
+        toMigrate.push({ path, targetPath, originalBytes, migratedBytes });
     }
     if (toMigrate.length === 0) {
         return;
     }
     try {
         for (const file of toMigrate) {
-            writeFileSync(file.path, file.migratedBytes);
+            if (file.targetPath !== file.path) {
+                mkdirSync(dirname(file.targetPath), { recursive: true });
+            }
+            writeFileSync(file.targetPath, file.migratedBytes);
+            if (file.targetPath !== file.path) {
+                unlinkSync(file.path);
+            }
+        }
+        const committedPaths = new Set();
+        for (const file of toMigrate) {
+            committedPaths.add(file.path);
+            committedPaths.add(file.targetPath);
         }
-        commitPaths(config.siteRoot, toMigrate.map((file) => file.path), `chore: migrate content to schema version ${currentVersion}`, author);
+        commitPaths(config.siteRoot, [...committedPaths], `chore: migrate content to schema version ${currentVersion}`, author);
     }
     catch (error) {
         const failures = rollback(toMigrate);

package/dist/services/publish.js

@@ -2,24 +2,18 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import { dirname } from 'node:path';
 import { GitOperationError, commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { postPathToUrl } from "./post-urls.js";
 import { loadRedirects, removeRedirectForPath, serialiseRedirects } from "./redirects.js";
 import { pagePathToUrl } from "./urls.js";
 import { validateContent } from "./validation.js";
 import { enqueue } from "./write-queue.js";
 const PAGES_PREFIX = 'pages/';
-const POSTS_PREFIX = 'posts/';
 // Mirrors delete-content.ts's urlForDeletedEntry - a tiny duplicated
-// helper, not a shared abstraction. Widens the stale-redirect-clearing
-// block below to posts alongside pages; returns null for anything
-// else (menus have no public URL, so redirect semantics don't apply).
+// helper, not a shared abstraction. Returns null for anything else
+// (menus have no public URL, so redirect semantics don't apply).
 function urlForPublishedEntry(relativePath) {
     if (relativePath.startsWith(PAGES_PREFIX)) {
         return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
     }
-    if (relativePath.startsWith(POSTS_PREFIX)) {
-        return postPathToUrl(relativePath.slice(POSTS_PREFIX.length));
-    }
     return null;
 }
 export class PublishError extends Error {
@@ -150,12 +144,12 @@ export function preparePublishDrafts(config, themeSchemas, relativePaths) {
             writeFileSync(entry.livePath, entry.draftContent);
             unlinkSync(entry.draftPath);
         }
-        // E5 (publish half): a brand-new live page or post may supersede a
-        // stale redirect recorded at its own URL (checklist wording:
-        // "creating a page at a path that has a redirect entry"). Only
-        // applies to pages/posts content - redirect semantics aren't
-        // defined for menus (no public URL), so anything else is skipped
-        // silently via urlForPublishedEntry's null return.
+        // E5 (publish half): a brand-new live page may supersede a stale
+        // redirect recorded at its own URL (checklist wording: "creating a
+        // page at a path that has a redirect entry"). Only applies to page
+        // content - redirect semantics aren't defined for menus (no public
+        // URL), so anything else is skipped silently via
+        // urlForPublishedEntry's null return.
         const qualifyingUrls = entries
             .map((entry) => urlForPublishedEntry(entry.relativePath))
             .filter((url) => url !== null);

package/dist/services/rate-limit-config.d.ts

@@ -1,7 +1,7 @@
 export declare const WRITE_ROUTE_RATE_LIMIT: {
     rateLimit: {};
 };
-export declare const CAPABILITIES_RATE_LIMIT: {
+export declare const NO_AUTH_ROUTE_RATE_LIMIT: {
     rateLimit: {
         max: number;
         timeWindow: number;

package/dist/services/rate-limit-config.js

@@ -14,7 +14,9 @@
 // route's own config.rateLimit only needs *something* present to opt
 // in, not a duplicated copy of the numbers.
 export const WRITE_ROUTE_RATE_LIMIT = { rateLimit: {} };
-// Generous defense-in-depth against basic scanning of the one endpoint
-// reachable with zero credentials, not a meaningful throttle on
-// legitimate use.
-export const CAPABILITIES_RATE_LIMIT = { rateLimit: { max: 300, timeWindow: 60000 } };
+// Generous defense-in-depth against basic scanning/abuse of the
+// endpoints reachable with zero credentials (GET /v1/capabilities,
+// GET /v1/search), not a meaningful throttle on legitimate use - a
+// real front-end calling search on every keystroke of a live search
+// box should never realistically hit this.
+export const NO_AUTH_ROUTE_RATE_LIMIT = { rateLimit: { max: 300, timeWindow: 60000 } };

package/dist/services/theme-schemas.js

@@ -40,14 +40,14 @@ function loadTypeSchemas(typesDir) {
         // A type whose required settings fields lack usable defaults is
         // skipped the same way a malformed schema block already is -
         // never a boot failure, just excluded from what gets registered
-        // (theme-authoring-guide.md, Group L).
+        // (guide-theme-authoring.md, Group L).
         if (!requiredFieldsHaveValidDefaults(parsed.schema)) {
             continue;
         }
         schemas[type] = parsed.schema;
         // The only place "does this type support nested blocks" is ever
         // expressed - a markup convention (does the template loop
-        // blocksHtml), not a schema field (theme-authoring-guide.md).
+        // blocksHtml), not a schema field (guide-theme-authoring.md).
         acceptsBlocks[type] = parsed.markup.includes('blocksHtml');
     }
     return { schemas, acceptsBlocks };

package/dist/services/validation.d.ts

@@ -18,7 +18,6 @@ export interface ThemeSchemas {
 export declare function requiredFieldsHaveValidDefaults(schema: object): boolean;
 export declare function validateInstance(instance: unknown, kind: 'section' | 'block', themeSchemas: ThemeSchemas): ValidationResult;
 export declare function validatePage(page: unknown, themeSchemas: ThemeSchemas): ValidationResult;
-export declare function validatePost(post: unknown, themeSchemas: ThemeSchemas): ValidationResult;
 export declare function validateMenu(menu: unknown): ValidationResult;
 export declare function validateRedirects(redirects: unknown): ValidationResult;
 export declare function validateContent(relativePath: string, content: unknown, themeSchemas: ThemeSchemas): ValidationResult;

package/dist/services/validation.js

@@ -12,7 +12,6 @@ function readSchema(filename) {
 const instanceSchema = readSchema('instance.schema.json');
 ajv.addSchema(instanceSchema);
 const validatePageEnvelope = ajv.compile(readSchema('page.schema.json'));
-const validatePostEnvelope = ajv.compile(readSchema('post.schema.json'));
 const validateMenuEnvelope = ajv.compile(readSchema('menu.schema.json'));
 const validateRedirectsEnvelope = ajv.compile(readSchema('redirects.schema.json'));
 const validateInstanceEnvelope = ajv.compile(instanceSchema);
@@ -112,10 +111,6 @@ export function validateInstance(instance, kind, themeSchemas) {
     }
     return { valid: errors.length === 0, errors };
 }
-// Shared by validatePage and validatePost: both envelopes require an
-// identical sections/blocks recursion once their own envelope-level
-// shape is confirmed valid - genuinely load-bearing for two real
-// content types now, not a speculative abstraction.
 function validateSectionedContent(envelopeValidate, content, themeSchemas) {
     const envelopeResult = runValidator(envelopeValidate, content);
     if (!envelopeResult.valid) {
@@ -132,9 +127,6 @@ function validateSectionedContent(envelopeValidate, content, themeSchemas) {
 export function validatePage(page, themeSchemas) {
     return validateSectionedContent(validatePageEnvelope, page, themeSchemas);
 }
-export function validatePost(post, themeSchemas) {
-    return validateSectionedContent(validatePostEnvelope, post, themeSchemas);
-}
 export function validateMenu(menu) {
     return runValidator(validateMenuEnvelope, menu);
 }
@@ -151,8 +143,5 @@ export function validateContent(relativePath, content, themeSchemas) {
     if (relativePath.startsWith('menus/')) {
         return validateMenu(content);
     }
-    if (relativePath.startsWith('posts/')) {
-        return validatePost(content, themeSchemas);
-    }
     return validatePage(content, themeSchemas);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-a/cms-agent",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -29,7 +29,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=22.16.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json",

package/dist/schemas/post.schema.json

@@ -1,25 +0,0 @@
-{
-  "$id": "post.schema.json",
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Post",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["schemaVersion", "title", "type", "layout", "published", "author", "publishDate", "tags", "sections"],
-  "properties": {
-    "schemaVersion": { "type": "integer", "minimum": 1 },
-    "title": { "type": "string", "minLength": 1 },
-    "type": { "const": "post" },
-    "layout": { "type": "string", "minLength": 1 },
-    "published": { "type": "boolean" },
-    "author": { "type": "string", "minLength": 1 },
-    "publishDate": { "type": "string", "minLength": 1 },
-    "tags": {
-      "type": "array",
-      "items": { "type": "string", "minLength": 1 }
-    },
-    "sections": {
-      "type": "array",
-      "items": { "$ref": "instance.schema.json" }
-    }
-  }
-}