koguma 2.1.0 → 2.2.0

package/cli/constants.ts

@@ -4,8 +4,26 @@
  * Eliminates magic strings scattered across modules.
  */
 
-/** CLI version string */
-export const CLI_VERSION = 'v2.0.0';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+
+/** CLI version string — read dynamically from package.json at runtime */
+function readCliVersion(): string {
+  try {
+    const pkgPath = resolve(
+      dirname(new URL(import.meta.url).pathname),
+      '..',
+      'package.json'
+    );
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as {
+      version?: string;
+    };
+    return `v${pkg.version ?? '?'}`;
+  } catch {
+    return 'v?';
+  }
+}
+export const CLI_VERSION = readCliVersion();
 
 /** Project config file name */
 export const CONFIG_FILE = 'koguma.toml';

package/cli/content.ts

@@ -7,15 +7,19 @@
  *   ├── post/
  *   │   ├── hello-world.md        # markdown body + frontmatter
  *   │   └── our-mission.md
- *   ├── siteSettings/
- *   │   └── index.md              # singletons use index.md
+ *   ├── landingPage/
+ *   │   ├── index.md              # singletons use index.md (1st md field = body)
+ *   │   ├── heroBody.md           # sibling file for extra markdown field
+ *   │   └── aboutBody.md          # sibling file for extra markdown field
  *   └── media/                    # optional local images (not managed here)
  *       └── hero.jpg
  *
  * All content files use the .md extension with YAML frontmatter.
  * The file body (below the frontmatter) is mapped to the first `markdown`
- * field in the content type definition. Files without a markdown field
- * are frontmatter-only .md files (no body below the --- delimiter).
+ * field in the content type definition. Additional markdown fields are
+ * stored as sibling .md files (pure markdown, no frontmatter):
+ *   - Singletons: {fieldId}.md alongside index.md
+ *   - Collections: {slug}.{fieldId}.md alongside {slug}.md
  *
  * Legacy .yml files are still accepted on read for backwards compatibility.
  */
@@ -113,13 +117,40 @@ export function parseContentFile(
 /**
  * Scan the content/ directory and return all parsed entries.
  * Skips the `media/` subdirectory and any files/directories starting with `_`.
+ *
+ * Also detects sibling .md files for extra markdown fields:
+ *   - Singletons: {fieldId}.md alongside index.md
+ *   - Collections: {slug}.{fieldId}.md alongside {slug}.md
+ *
+ * Returns a siblingMap: Map<"contentType/slug", Record<fieldId, markdownContent>>
  */
-export function readContentDir(contentDir: string): ContentEntry[] {
-  if (!existsSync(contentDir)) return [];
+export function readContentDir(
+  contentDir: string,
+  contentTypes?: ContentTypeInfo[]
+): {
+  entries: ContentEntry[];
+  siblingMap: Map<string, Record<string, string>>;
+} {
+  if (!existsSync(contentDir)) return { entries: [], siblingMap: new Map() };
 
   const entries: ContentEntry[] = [];
+  const siblingMap = new Map<string, Record<string, string>>();
   const subdirs = readdirSync(contentDir);
 
+  // Build a set of markdown field IDs per content type for sibling detection
+  const ctMdFields = new Map<string, Set<string>>();
+  if (contentTypes) {
+    for (const ct of contentTypes) {
+      const mdFields = Object.entries(ct.fieldMeta)
+        .filter(([, meta]) => meta.fieldType === 'markdown')
+        .map(([id]) => id);
+      // Only care about extra fields (skip the first — it goes in the main body)
+      if (mdFields.length > 1) {
+        ctMdFields.set(ct.id, new Set(mdFields.slice(1)));
+      }
+    }
+  }
+
   for (const subdir of subdirs) {
     // Skip media/ — it's for local image storage, not content
     if (subdir === 'media') continue;
@@ -130,25 +161,93 @@ export function readContentDir(contentDir: string): ContentEntry[] {
     if (!statSync(subdirPath).isDirectory()) continue;
 
     const files = readdirSync(subdirPath);
+    const extraMdFieldIds = ctMdFields.get(subdir);
+
+    // First pass: identify main content files vs sibling field files
+    const mainFiles: string[] = [];
+    const siblingFiles: string[] = [];
+
     for (const file of files) {
-      // Skip _-prefixed files (_example.md, dev drafts, etc.)
       if (file.startsWith('_')) continue;
-
       const ext = extname(file).toLowerCase();
       if (!['.md', '.yml', '.yaml'].includes(ext)) continue;
 
       const filePath = resolve(subdirPath, file);
       if (!statSync(filePath).isFile()) continue;
 
+      const name = basename(file, ext);
+
+      // Check if this is a sibling field file
+      if (ext === '.md' && extraMdFieldIds) {
+        // Singleton sibling: fieldId.md (not index.md)
+        if (name !== 'index' && extraMdFieldIds.has(name)) {
+          siblingFiles.push(file);
+          continue;
+        }
+        // Collection sibling: slug.fieldId.md
+        const dotIdx = name.lastIndexOf('.');
+        if (dotIdx > 0) {
+          const maybeFieldId = name.slice(dotIdx + 1);
+          if (extraMdFieldIds.has(maybeFieldId)) {
+            siblingFiles.push(file);
+            continue;
+          }
+        }
+      }
+
+      mainFiles.push(file);
+    }
+
+    // Parse main content files
+    for (const file of mainFiles) {
+      const filePath = resolve(subdirPath, file);
       entries.push(parseContentFile(filePath, subdir));
     }
+
+    // Parse sibling field files and merge into siblingMap
+    for (const file of siblingFiles) {
+      const ext = extname(file).toLowerCase();
+      const name = basename(file, ext);
+      const content = readFileSync(resolve(subdirPath, file), 'utf-8').trim();
+
+      // Determine which entry this belongs to and which field
+      const dotIdx = name.lastIndexOf('.');
+      if (dotIdx > 0) {
+        // Collection: slug.fieldId.md
+        const slug = name.slice(0, dotIdx);
+        const fieldId = name.slice(dotIdx + 1);
+        const key = `${subdir}/${slug}`;
+        const existing = siblingMap.get(key) ?? {};
+        existing[fieldId] = content;
+        siblingMap.set(key, existing);
+      } else {
+        // Singleton: fieldId.md → key is contentType/contentType
+        const fieldId = name;
+        const key = `${subdir}/${subdir}`;
+        const existing = siblingMap.get(key) ?? {};
+        existing[fieldId] = content;
+        siblingMap.set(key, existing);
+      }
+    }
   }
 
-  return entries;
+  return { entries, siblingMap };
 }
 
 // ── Convert ContentEntry → D1 row data ─────────────────────────────
 
+/**
+ * Find ALL markdown field IDs in a content type's field metadata.
+ * Returns an ordered array (first element = primary body field).
+ */
+export function findMarkdownFields(
+  fieldMeta: Record<string, { fieldType: string }>
+): string[] {
+  return Object.entries(fieldMeta)
+    .filter(([, meta]) => meta.fieldType === 'markdown')
+    .map(([id]) => id);
+}
+
 /**
  * Find the first markdown field ID in a content type's field metadata.
  * Returns null if the content type has no markdown field.
@@ -156,19 +255,18 @@ export function readContentDir(contentDir: string): ContentEntry[] {
 export function findMarkdownField(
   fieldMeta: Record<string, { fieldType: string }>
 ): string | null {
-  for (const [id, meta] of Object.entries(fieldMeta)) {
-    if (meta.fieldType === 'markdown') return id;
-  }
-  return null;
+  return findMarkdownFields(fieldMeta)[0] ?? null;
 }
 
 /**
  * Convert a ContentEntry into the flat data object suitable for D1 insertion.
  * The markdown body (if present) is assigned to the first markdown field.
+ * Additional markdown fields can be passed in via siblingFields.
  */
 export function contentEntryToDbRow(
   entry: ContentEntry,
-  ctInfo: ContentTypeInfo
+  ctInfo: ContentTypeInfo,
+  siblingFields?: Record<string, string>
 ): Record<string, unknown> {
   const data: Record<string, unknown> = { ...entry.fields };
 
@@ -180,6 +278,13 @@ export function contentEntryToDbRow(
     }
   }
 
+  // Merge sibling markdown fields
+  if (siblingFields) {
+    for (const [fieldId, content] of Object.entries(siblingFields)) {
+      data[fieldId] = content;
+    }
+  }
+
   // Set slug
   if (!data.slug && !entry.singleton) {
     data.slug = entry.slug;
@@ -219,7 +324,11 @@ export function contentEntryToDbRow(
 export function dbRowToContentFile(
   row: Record<string, unknown>,
   ctInfo: ContentTypeInfo
-): { content: string; extension: string } {
+): {
+  content: string;
+  extension: string;
+  siblingFiles?: { fieldId: string; content: string }[];
+} {
   // Parse the data blob if it's still a JSON string
   let fields: Record<string, unknown>;
   if (typeof row.data === 'string') {
@@ -242,22 +351,38 @@ export function dbRowToContentFile(
   // Strip system-only fields from frontmatter
   delete fields.slug;
 
-  const mdFieldId = findMarkdownField(ctInfo.fieldMeta);
+  const mdFields = findMarkdownFields(ctInfo.fieldMeta);
+  const primaryMdField = mdFields[0] ?? null;
+  const extraMdFields = mdFields.slice(1);
+
+  // Collect sibling files for extra markdown fields
+  const siblingFiles: { fieldId: string; content: string }[] = [];
+  for (const fieldId of extraMdFields) {
+    if (fields[fieldId]) {
+      siblingFiles.push({ fieldId, content: String(fields[fieldId]) });
+      delete fields[fieldId]; // Don't put in frontmatter
+    }
+  }
 
-  if (mdFieldId && fields[mdFieldId]) {
+  if (primaryMdField && fields[primaryMdField]) {
     // Markdown file: body goes below frontmatter
-    const body = String(fields[mdFieldId]);
-    delete fields[mdFieldId];
+    const body = String(fields[primaryMdField]);
+    delete fields[primaryMdField];
     const fm = matter.stringify('', fields).trim();
     return {
       content: `${fm}\n\n${body}\n`,
-      extension: '.md'
+      extension: '.md',
+      ...(siblingFiles.length > 0 ? { siblingFiles } : {})
     };
   }
 
   // Frontmatter-only file (no markdown field or empty body)
   const fm = matter.stringify('', fields).trim();
-  return { content: fm + '\n', extension: '.md' };
+  return {
+    content: fm + '\n',
+    extension: '.md',
+    ...(siblingFiles.length > 0 ? { siblingFiles } : {})
+  };
 }
 
 // ── Write content/ directory from D1 entries ───────────────────────
@@ -287,7 +412,10 @@ export function writeContentDir(
     const typeDir = resolve(contentDir, typeId);
     mkdirSync(typeDir, { recursive: true });
 
-    const { content, extension } = dbRowToContentFile(entry, ctInfo);
+    const { content, extension, siblingFiles } = dbRowToContentFile(
+      entry,
+      ctInfo
+    );
 
     // Determine filename
     const slug = (entry.slug as string) || (entry.id as string);
@@ -296,6 +424,17 @@ export function writeContentDir(
 
     writeFileSync(resolve(typeDir, filename), content);
     count++;
+
+    // Write sibling files for extra markdown fields
+    if (siblingFiles) {
+      for (const { fieldId, content: siblingContent } of siblingFiles) {
+        const siblingName = isSingleton
+          ? `${fieldId}.md`
+          : `${slug}.${fieldId}.md`;
+        writeFileSync(resolve(typeDir, siblingName), siblingContent + '\n');
+        count++;
+      }
+    }
   }
 
   return count;
@@ -316,16 +455,21 @@ export function prepareContentForSync(
   contentTypes: ContentTypeInfo[]
 ): { contentType: string; rowData: Record<string, unknown> }[] {
   const ctMap = new Map(contentTypes.map(ct => [ct.id, ct]));
-  const entries = readContentDir(contentDir);
+  const { entries, siblingMap } = readContentDir(contentDir, contentTypes);
   const results: { contentType: string; rowData: Record<string, unknown> }[] =
     [];
 
   for (const entry of entries) {
     const ctInfo = ctMap.get(entry.contentType);
     if (!ctInfo) continue;
+
+    // Look up sibling markdown fields for this entry
+    const entryKey = `${entry.contentType}/${entry.slug}`;
+    const siblings = siblingMap.get(entryKey);
+
     results.push({
       contentType: entry.contentType,
-      rowData: contentEntryToDbRow(entry, ctInfo)
+      rowData: contentEntryToDbRow(entry, ctInfo, siblings)
     });
   }
 

package/cli/dev-sync.ts

@@ -3,17 +3,32 @@
  *
  * Two event-driven sync paths:
  *   1. File watcher:  content/ file changes → parse → INSERT OR REPLACE into D1
+ *                    content/media/ image changes → put/delete in local R2 + assets table
  *   2. Sync server:   router webhook (POST /sync) → write content/ file
+ *                    router webhook (POST /sync/media) → write file to content/media/
+ *                    router webhook (DELETE /sync/media/:filename) → remove from content/media/
  *
  * Loop prevention: a shared cooldown map tracks recent writes by entry ID.
  * When either side writes, it records the ID. The other side skips that ID
  * for a short cooldown window to prevent infinite loops.
  */
 
-import { watch, existsSync, statSync } from 'fs';
-import { resolve, relative, join, extname, sep } from 'path';
+import {
+  watch,
+  existsSync,
+  statSync,
+  writeFileSync,
+  unlinkSync,
+  mkdirSync
+} from 'fs';
+import { resolve, relative, join, extname, basename, sep } from 'path';
 import { log, ok, warn, ANSI } from './log.ts';
-import { d1InsertRow, applySchema, type D1Target } from './wrangler.ts';
+import {
+  d1InsertRow,
+  applySchema,
+  r2PutLocal,
+  type D1Target
+} from './wrangler.ts';
 import { buildInsertSql } from '../src/db/sql.ts';
 import {
   parseContentFile,
@@ -81,7 +96,7 @@ function startFileWatcher(opts: FileWatcherOptions): { stop: () => void } {
     const ext = extname(filename);
     if (ext !== '.md' && ext !== '.yml' && ext !== '.yaml') return;
 
-    // Skip media/ subdirectory
+    // Skip media/ subdirectory — handled separately by the media watcher
     if (filename.startsWith('media' + sep) || filename.startsWith('media/'))
       return;
 
@@ -118,8 +133,14 @@ function startFileWatcher(opts: FileWatcherOptions): { stop: () => void } {
           // Pack into v2 format: entries(id, content_type, slug, data, status)
           const rowData = contentEntryToDbRow(entry, ctInfo);
           const {
-            id, slug: rowSlug, status, publish_at, publishAt,
-            created_at: _ca, updated_at: _ua, content_type: _ct,
+            id,
+            slug: rowSlug,
+            status,
+            publish_at,
+            publishAt,
+            created_at: _ca,
+            updated_at: _ua,
+            content_type: _ct,
             ...fields
           } = rowData;
           d1InsertRow(root, dbName, '--local', 'entries', {
@@ -152,6 +173,129 @@ function startFileWatcher(opts: FileWatcherOptions): { stop: () => void } {
   };
 }
 
+// ── Media file watcher: content/media/ → local R2 ─────────────────
+
+const MEDIA_EXTENSIONS = new Set([
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.webp',
+  '.svg',
+  '.avif',
+  '.ico'
+]);
+const MIME_TYPES: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.avif': 'image/avif',
+  '.ico': 'image/x-icon'
+};
+
+interface MediaWatcherOptions {
+  root: string;
+  dbName: string;
+}
+
+function startMediaWatcher(opts: MediaWatcherOptions): { stop: () => void } {
+  const { root, dbName } = opts;
+  const mediaDir = resolve(root, 'content/media');
+
+  if (!existsSync(mediaDir)) return { stop: () => {} };
+
+  const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  const watcher = watch(mediaDir, (_event, filename) => {
+    if (!filename) return;
+    const ext = extname(filename).toLowerCase();
+    if (!MEDIA_EXTENSIONS.has(ext)) return;
+    if (filename.startsWith('.') || filename.startsWith('_')) return;
+
+    const existing = debounceTimers.get(filename);
+    if (existing) clearTimeout(existing);
+
+    debounceTimers.set(
+      filename,
+      setTimeout(() => {
+        debounceTimers.delete(filename);
+        const filePath = resolve(mediaDir, filename);
+
+        if (!existsSync(filePath)) {
+          // File removed — delete from local R2 + assets table
+          const id = `media-${filename.replace(/\.\w+$/, '')}`;
+          const key = `media-${filename.replace(/\.\w+$/, '')}${ext}`;
+          try {
+            const { run } = require('./exec.ts');
+            // Remove from local R2
+            const { ensureWranglerConfig } = require('./config.ts');
+            const configPath = ensureWranglerConfig(root);
+            run(
+              `bunx wrangler r2 object delete ${key} --config ${configPath} --local`,
+              { cwd: root, silent: true }
+            );
+          } catch {
+            /* R2 object may not exist */
+          }
+          try {
+            d1InsertRow(root, dbName, '--local', 'assets', { id, _delete: 1 });
+          } catch {
+            /* may not exist */
+          }
+          // Use a direct DELETE instead
+          try {
+            const { run } = require('./exec.ts');
+            const { ensureWranglerConfig } = require('./config.ts');
+            const configPath = ensureWranglerConfig(root);
+            run(
+              `bunx wrangler d1 execute ${dbName} --local --config ${configPath} --command "DELETE FROM assets WHERE id = '${id}'"`,
+              { cwd: root, silent: true }
+            );
+          } catch {
+            /* ignore */
+          }
+          ok(
+            `${ANSI.DIM}sync:${ANSI.RESET} media/${filename} removed from local R2`
+          );
+          return;
+        }
+
+        // File added/changed — put into local R2 + upsert assets table
+        const id = `media-${filename.replace(/\.\w+$/, '')}`;
+        const key = `${id}${ext}`;
+        try {
+          r2PutLocal(root, 'media', key, filePath);
+          d1InsertRow(root, dbName, '--local', 'assets', {
+            id,
+            data: JSON.stringify({
+              title: filename,
+              url: `/api/media/${key}`,
+              content_type: MIME_TYPES[ext] ?? 'application/octet-stream',
+              width: null,
+              height: null,
+              file_size: null
+            })
+          });
+          ok(`${ANSI.DIM}sync:${ANSI.RESET} media/${filename} → local R2`);
+        } catch (e) {
+          warn(`Media sync failed for ${filename}: ${e}`);
+        }
+      }, 300)
+    );
+  });
+
+  return {
+    stop: () => {
+      watcher.close();
+      for (const timer of debounceTimers.values()) clearTimeout(timer);
+      debounceTimers.clear();
+    }
+  };
+}
+
 // ── Sync server: router webhook → content/ files ───────────────────
 
 interface SyncServerOptions {
@@ -167,13 +311,19 @@ export function killStalePortHolder(port: number): void {
       for (const pid of out.split('\n')) {
         const n = parseInt(pid, 10);
         if (n > 0 && n !== process.pid) {
-          try { process.kill(n, 'SIGTERM'); } catch { /* already gone */ }
+          try {
+            process.kill(n, 'SIGTERM');
+          } catch {
+            /* already gone */
+          }
         }
       }
       // Brief pause to let the OS release the socket
       execSync('sleep 0.2');
     }
-  } catch { /* lsof not found or no process — fine */ }
+  } catch {
+    /* lsof not found or no process — fine */
+  }
 }
 
 function startSyncServer(opts: SyncServerOptions): {
@@ -248,6 +398,50 @@ function startSyncServer(opts: SyncServerOptions): {
         }
       }
 
+      // ── POST /sync/media — write uploaded file to content/media/ ──
+      if (req.method === 'POST' && url.pathname === '/sync/media') {
+        try {
+          const form = await req.formData();
+          const file = form.get('file') as File | null;
+          const filename = form.get('filename') as string | null;
+          if (!file || !filename)
+            return new Response('Missing file or filename', { status: 400 });
+
+          const mediaDir = resolve(contentDir, 'media');
+          if (!existsSync(mediaDir)) mkdirSync(mediaDir, { recursive: true });
+
+          const buf = Buffer.from(await file.arrayBuffer());
+          writeFileSync(resolve(mediaDir, filename), buf);
+          ok(
+            `${ANSI.DIM}sync:${ANSI.RESET} dashboard → content/media/${filename}`
+          );
+          return new Response('ok');
+        } catch (e) {
+          warn(`Media sync write error: ${e}`);
+          return new Response('error', { status: 500 });
+        }
+      }
+
+      // ── DELETE /sync/media/:filename — remove from content/media/ ──
+      if (req.method === 'DELETE' && url.pathname.startsWith('/sync/media/')) {
+        try {
+          const filename = decodeURIComponent(
+            url.pathname.slice('/sync/media/'.length)
+          );
+          const filePath = resolve(contentDir, 'media', filename);
+          if (existsSync(filePath)) {
+            unlinkSync(filePath);
+            ok(
+              `${ANSI.DIM}sync:${ANSI.RESET} dashboard deleted content/media/${filename}`
+            );
+          }
+          return new Response('ok');
+        } catch (e) {
+          warn(`Media sync delete error: ${e}`);
+          return new Response('error', { status: 500 });
+        }
+      }
+
       return new Response('not found', { status: 404 });
     }
   });
@@ -288,16 +482,20 @@ export function startDevSync(
 
   // Start both sync paths
   const fileWatcher = startFileWatcher({ root, dbName, contentTypes });
+  const mediaWatcher = startMediaWatcher({ root, dbName });
   const syncServer = startSyncServer({ root, contentTypes });
 
   if (!opts?.silent) {
-    ok(`Dev sync active — file watcher + sync server on :${syncServer.port}`);
+    ok(
+      `Dev sync active — file watcher + media watcher + sync server on :${syncServer.port}`
+    );
   }
 
   return {
     syncUrl: `http://localhost:${syncServer.port}`,
     stop: () => {
       fileWatcher.stop();
+      mediaWatcher.stop();
       syncServer.stop();
       recentWrites.clear();
     }