@glw907/cairn-cms 0.59.0 → 0.60.1

package/src/lib/nav/site-config.ts

@@ -81,9 +81,182 @@ export interface SiteConfig {
   menus?: Record<string, unknown>;
   /** Per-concept URL policy: the permalink pattern and date-prefix granularity, keyed by concept id. */
   content?: Record<string, ConceptUrlPolicy>;
+  /** The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
+   *  site loads the British word list and "colour" reads as correct. Today only US English ships, so an
+   *  unset or unknown dialect resolves to it. */
+  spellcheck?: { dialect?: string };
+  /** The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
+   *  costly model call, so the whole block is optional and `enabled` defaults false. The model is a
+   *  developer-tier fact; the `conventions` block is the editor-tier per-convention config that builds
+   *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config. */
+  tidy?: TidyConfig;
   [key: string]: unknown;
 }
 
+/**
+ * The tidy block on the site config. Every field is optional so the YAML can carry as little as
+ * `tidy: { enabled: true }` and the defaults fill the rest.
+ */
+export interface TidyConfig {
+  /** Master switch. Default false; tidy is opt-in (spec 2.8, decision 1). */
+  enabled?: boolean;
+  /** The model id. Default `claude-sonnet-4-6`; the alternative is `claude-haiku-4-5` (spec 2.2). */
+  model?: string;
+  /** The per-convention toggles that build the prompt's CONVENTIONS section. */
+  conventions?: Partial<TidyConventions>;
+}
+
+/** The default tidy model when a site sets none: Sonnet, the judgment floor for a light copy-edit. */
+export const DEFAULT_TIDY_MODEL = 'claude-sonnet-4-6';
+
+/**
+ * The corrected convention set (spec "The corrected convention set"), the resolved shape the prompt
+ * builder consumes. Every field carries a concrete value; `resolveTidyConventions` fills the defaults
+ * from a partial config. The Fixes group is the objective fixes (default on, governed by the always-on
+ * core); the style tier defaults off (a falsy variant means off); the advanced tier defaults off.
+ * Sentence spacing is dropped on purpose and regional spelling is `spellcheck.dialect`, not a toggle.
+ */
+export interface TidyConventions {
+  /** The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
+   *  punctuation). Default on. The always-on core governs it; this toggle lets the screen turn the
+   *  group off. */
+  fixes: boolean;
+  /** Oxford comma position. Off when undefined; `always` | `complex-only` (AP) | `never`. */
+  oxfordComma?: 'always' | 'complex-only' | 'never';
+  /** Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
+   *  measurements, percentages) apply at any threshold. */
+  numberStyle?: 'under-ten' | 'under-hundred' | 'always-numerals';
+  /** Measurement notation only (never the system, never the number). Off when undefined. */
+  measurements?: 'abbreviate' | 'spell-out';
+  /** Percent rendering. Off when undefined; `sign` is "%", `word` is "percent". */
+  percent?: 'sign' | 'word';
+  /** Em-dash spacing. Off when undefined. */
+  emDash?: 'spaced' | 'closed';
+  /** Turn a hyphen between two numbers into an en dash. Default off. */
+  enDashRanges: boolean;
+  /** Ellipsis rendering. Off when undefined. */
+  ellipsis?: 'single-char' | 'three-dots';
+  /** Time format. Off when undefined. */
+  timeFormat?: '5 PM' | '5pm' | '5 p.m.';
+  /** Advanced: convert straight quotes to curly with the full apostrophe rule set. Default off. */
+  smartQuotes: boolean;
+  /** Advanced: correct brand and proper-noun capitalization on a curated list only. Default off. */
+  brandCaps: boolean;
+}
+
+/** The resting tidy convention set: Fixes on, every style and advanced toggle off. */
+export function defaultTidyConventions(): TidyConventions {
+  return { fixes: true, enDashRanges: false, smartQuotes: false, brandCaps: false };
+}
+
+/**
+ * Resolve a partial conventions config (from the YAML) into the concrete TidyConventions the prompt
+ * builder consumes. An absent field falls to its default: Fixes on, the style and advanced toggles
+ * off. A multi-position toggle stays undefined (off) unless the config names a variant.
+ */
+export function resolveTidyConventions(partial: Partial<TidyConventions> | undefined): TidyConventions {
+  const base = defaultTidyConventions();
+  if (partial === undefined) return base;
+  return {
+    fixes: partial.fixes ?? base.fixes,
+    oxfordComma: partial.oxfordComma,
+    numberStyle: partial.numberStyle,
+    measurements: partial.measurements,
+    percent: partial.percent,
+    emDash: partial.emDash,
+    enDashRanges: partial.enDashRanges ?? base.enDashRanges,
+    ellipsis: partial.ellipsis,
+    timeFormat: partial.timeFormat,
+    smartQuotes: partial.smartQuotes ?? base.smartQuotes,
+    brandCaps: partial.brandCaps ?? base.brandCaps,
+  };
+}
+
+// The allowed values for each multi-position style toggle, the single source the validator checks an
+// untrusted settings payload against. A value outside its list is rejected, so the committed YAML can
+// only ever carry a known variant the prompt builder understands.
+const OXFORD_COMMA_VALUES = ['always', 'complex-only', 'never'] as const;
+const NUMBER_STYLE_VALUES = ['under-ten', 'under-hundred', 'always-numerals'] as const;
+const MEASUREMENTS_VALUES = ['abbreviate', 'spell-out'] as const;
+const PERCENT_VALUES = ['sign', 'word'] as const;
+const EM_DASH_VALUES = ['spaced', 'closed'] as const;
+const ELLIPSIS_VALUES = ['single-char', 'three-dots'] as const;
+const TIME_FORMAT_VALUES = ['5 PM', '5pm', '5 p.m.'] as const;
+
+export class TidyConventionsError extends Error {
+  /** A malformed settings payload maps to the same diagnostic as a malformed config. */
+  readonly conditionId = 'config.site-config-invalid';
+
+  constructor(message: string) {
+    super(message);
+    this.name = 'TidyConventionsError';
+  }
+}
+
+/**
+ * Validate and normalize an untrusted conventions object (from the settings form) into a concrete
+ * TidyConventions. This input is committed to the repo, so every field is bounded to its known set:
+ * a boolean toggle must be a boolean, and a multi-position toggle must be one of its listed variants
+ * or absent (off). An unknown key is dropped rather than carried, so the committed block can never
+ * grow a junk key. Throws TidyConventionsError on a value outside its allowed set.
+ */
+export function validateTidyConventions(value: unknown): TidyConventions {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new TidyConventionsError('Tidy conventions must be an object');
+  }
+  const input = value as Record<string, unknown>;
+
+  function bool(key: string, fallback: boolean): boolean {
+    const v = input[key];
+    if (v === undefined) return fallback;
+    if (typeof v !== 'boolean') throw new TidyConventionsError(`${key} must be true or false`);
+    return v;
+  }
+  function variant<T extends string>(key: string, allowed: readonly T[]): T | undefined {
+    const v = input[key];
+    if (v === undefined || v === null || v === false) return undefined;
+    if (typeof v !== 'string' || !(allowed as readonly string[]).includes(v)) {
+      throw new TidyConventionsError(`${key} must be one of ${allowed.join(', ')}`);
+    }
+    return v as T;
+  }
+
+  return {
+    fixes: bool('fixes', true),
+    oxfordComma: variant('oxfordComma', OXFORD_COMMA_VALUES),
+    numberStyle: variant('numberStyle', NUMBER_STYLE_VALUES),
+    measurements: variant('measurements', MEASUREMENTS_VALUES),
+    percent: variant('percent', PERCENT_VALUES),
+    emDash: variant('emDash', EM_DASH_VALUES),
+    enDashRanges: bool('enDashRanges', false),
+    ellipsis: variant('ellipsis', ELLIPSIS_VALUES),
+    timeFormat: variant('timeFormat', TIME_FORMAT_VALUES),
+    smartQuotes: bool('smartQuotes', false),
+    brandCaps: bool('brandCaps', false),
+  };
+}
+
+/** The dialect string when a site sets none: US English, the only dictionary that ships today. */
+export const DEFAULT_DIALECT = 'en-US';
+
+// The dialect-to-dictionary map. Only US English ships now; a new locale adds one entry here and one
+// committed dictionary file under spellcheck-assets, and the rest of the chain (the main-thread URL
+// resolution, the worker fetch) needs no change. An unknown or unset dialect falls back to the default
+// rather than throwing, so a typo or a future-locale config never breaks the editor.
+const DICTIONARY_BY_DIALECT: Record<string, string> = {
+  'en-US': 'dictionary-en-us.txt',
+};
+
+/**
+ * The dictionary asset file for a site's configured dialect, defaulting to US English. The main thread
+ * resolves this filename to a real URL (the spike's out-of-bundle asset) and hands it to the Worker in
+ * the `init` message; the Worker never reads config. An unknown dialect falls back to the default file.
+ */
+export function dictionaryFileForDialect(dialect: string | undefined): string {
+  const key = dialect ?? DEFAULT_DIALECT;
+  return DICTIONARY_BY_DIALECT[key] ?? DICTIONARY_BY_DIALECT[DEFAULT_DIALECT]!;
+}
+
 export class SiteConfigError extends Error {
   /** The registered diagnostic condition a malformed site config maps to (mirrors CairnError). */
   readonly conditionId = 'config.site-config-invalid';
@@ -133,3 +306,27 @@ export function setMenu(raw: string, name: string, tree: NavNode[]): string {
   doc.setIn(['menus', name], tree);
   return doc.toString();
 }
+
+/**
+ * Write the editor-tier tidy conventions into the YAML site-config text and reserialize, preserving
+ * every other top-level key and the file's comments and key order (parseDocument round-trips both,
+ * the same machinery setMenu uses). Only the `tidy.conventions` block is touched: the developer-tier
+ * `tidy.enabled` and `tidy.model` are read-only in the screen, so this leaves them as they are and a
+ * save can never silently flip the deploy-time facts. A convention whose value is undefined (a
+ * collapsed multi-position toggle, off) is dropped, so the committed block carries only the on
+ * toggles, the same shape `resolveTidyConventions` fills the defaults back from on read.
+ */
+export function setTidy(raw: string, conventions: Partial<TidyConventions>): string {
+  const doc = parseDocument(raw);
+  if (doc.get('siteName') === undefined) {
+    throw new SiteConfigError('Site config must be a mapping with a siteName');
+  }
+  // Drop undefined-valued keys (a collapsed multi-position toggle) so the committed YAML carries only
+  // the enabled conventions; the resolver fills the rest back from defaults on read.
+  const block: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(conventions)) {
+    if (value !== undefined) block[key] = value;
+  }
+  doc.setIn(['tidy', 'conventions'], block);
+  return doc.toString();
+}

package/src/lib/sveltekit/admin-dispatch.ts

@@ -16,13 +16,14 @@ export type AdminView =
   | { view: 'edit'; concept: ConceptDescriptor; id: string }
   | { view: 'editors' }
   | { view: 'nav' }
-  | { view: 'media' };
+  | { view: 'media' }
+  | { view: 'settings' };
 
 /**
  * Fixed first segments that never resolve as concepts. The engine only allows posts and pages
  * today, so no collision is possible, but the parser does not depend on that: a reserved
- * segment wins before concept lookup. `settings` has no view yet; AdminLayout already links
- * the sidebar to /admin/settings, so the URL is spoken for.
+ * segment wins before concept lookup. `settings`, `nav`, and `media` are decided as views below,
+ * so they are not in this no-view set.
  */
 const RESERVED_SEGMENTS = new Set(['login', 'auth', 'editors', 'nav', 'settings']);
 
@@ -62,6 +63,9 @@ export function parseAdminPath(
     // reserved-no-view set. /admin/media/<anything> 404s naturally (media is not a configured
     // concept), which is the correct shape.
     if (head === 'media') return { view: 'media' };
+    // settings is its own view, a peer of editors and nav. /admin/settings/<anything> 404s naturally
+    // (the two-segment branch never matches settings), which is the correct shape.
+    if (head === 'settings') return { view: 'settings' };
     if (RESERVED_SEGMENTS.has(head)) return null;
     const concept = findConcept(concepts, head);
     return concept ? { view: 'list', concept } : null;

package/src/lib/sveltekit/cairn-admin.ts

@@ -15,6 +15,7 @@ import {
   type ListData,
   type EditData,
   type MediaLibraryData,
+  type SettingsData,
 } from './content-routes.js';
 import { createEditorRoutes } from './editors-routes.js';
 import { createNavRoutes, type NavLoadData } from './nav-routes.js';
@@ -41,6 +42,11 @@ export interface CairnAdminDeps {
   branding?: AuthBranding;
   send?: SendMagicLink;
   mintToken?: ContentRoutesDeps['mintToken'];
+  /** Build the Anthropic client for the tidy action. Forwarded to the content routes; a site that
+   *  enables tidy injects a stub here to avoid a real network call. Defaults to the real SDK client. */
+  anthropic?: ContentRoutesDeps['anthropic'];
+  /** The tidy action's own request deadline in milliseconds. Forwarded to the content routes. */
+  tidyTimeoutMs?: ContentRoutesDeps['tidyTimeoutMs'];
 }
 
 /**
@@ -55,7 +61,8 @@ export type AdminData =
   | { view: 'edit'; layout: LayoutData; page: EditData }
   | { view: 'editors'; layout: LayoutData; page: { editors: Editor[]; self: string } }
   | { view: 'nav'; layout: LayoutData; page: NavLoadData }
-  | { view: 'media'; layout: LayoutData; page: MediaLibraryData };
+  | { view: 'media'; layout: LayoutData; page: MediaLibraryData }
+  | { view: 'settings'; layout: LayoutData; page: SettingsData };
 
 export function createCairnAdmin(runtime: CairnRuntime, deps: CairnAdminDeps = {}) {
   // The runtime already composes the site name and the sender identity, so the magic-link
@@ -66,7 +73,11 @@ export function createCairnAdmin(runtime: CairnRuntime, deps: CairnAdminDeps = {
     replyTo: runtime.sender.replyTo,
   };
   const auth = createAuthRoutes({ branding, send: deps.send });
-  const content = createContentRoutes(runtime, { mintToken: deps.mintToken });
+  const content = createContentRoutes(runtime, {
+    mintToken: deps.mintToken,
+    anthropic: deps.anthropic,
+    tidyTimeoutMs: deps.tidyTimeoutMs,
+  });
   const editors = createEditorRoutes();
   // The nav surface exists only when the site configures a menu; without one its view is a 404.
   const nav = runtime.navMenu ? createNavRoutes(runtime, { mintToken: deps.mintToken }) : null;
@@ -129,6 +140,11 @@ export function createCairnAdmin(runtime: CairnRuntime, deps: CairnAdminDeps = {
         const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.mediaLibraryLoad(delegated)]);
         return { view: 'media', layout, page };
       }
+      case 'settings': {
+        const delegated = contentEvent(event, {});
+        const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.settingsLoad(delegated)]);
+        return { view: 'settings', layout, page };
+      }
     }
   }
 
@@ -148,9 +164,9 @@ export function createCairnAdmin(runtime: CairnRuntime, deps: CairnAdminDeps = {
   }
 
   // The topbar posts publishAll from every authed admin page; login and confirm may not.
-  const authedViews = ['list', 'edit', 'editors', 'nav', 'media'] as const;
+  const authedViews = ['list', 'edit', 'editors', 'nav', 'media', 'settings'] as const;
   // An editor signs out from wherever they are, so logout accepts any parsed view.
-  const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media'] as const;
+  const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media', 'settings'] as const;
 
   /** The full admin action vocabulary, one named async function per action, so a site's
    *  catch-all route exports `admin.actions` directly. Each wrapper stays thin: parse,
@@ -166,10 +182,22 @@ export function createCairnAdmin(runtime: CairnRuntime, deps: CairnAdminDeps = {
       if (!nav) throw error(404, 'Not found');
       return nav.navSave(contentEvent(event, {}));
     }),
+    // The tidy settings save (spec 2.8, Task 15): the editor commits the per-convention block to the
+    // committed YAML. Gated to the settings view, so it 404s elsewhere; the action itself 404s again
+    // when tidy is off, the server half of the truthful visibility gate.
+    saveSettings: viewAction(['settings'], (event) => content.settingsSave(contentEvent(event, {}))),
     upload: viewAction(['edit'], (event, view) => content.uploadAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
     publish: viewAction(['edit'], (event, view) => content.publishAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
     discard: viewAction(['edit'], (event, view) => content.discardAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
     rename: viewAction(['edit'], (event, view) => content.renameAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
+    // The personal-dictionary add (spec 1.6): the editor commits its pending add-to-dictionary words at
+    // save time. Gated to the edit view, where the spellcheck surface lives, so it 404s elsewhere.
+    addDictionaryWord: viewAction(['edit'], (event, view) =>
+      content.addDictionaryWord(contentEvent(event, { concept: view.concept.id, id: view.id }))),
+    // Tidy (spec 2.1): the editor posts the buffer to `?/tidy` for a light LLM copy-edit. Gated to the
+    // edit view, where the review surface lives, so it 404s elsewhere.
+    tidy: viewAction(['edit'], (event, view) =>
+      content.tidyAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
     delete: viewAction(['edit', 'list'], (event, view) =>
       view.view === 'edit'
         ? content.deleteAction(contentEvent(event, { concept: view.concept.id, id: view.id }))