koguma 2.1.0 → 2.2.1

package/cli/index.ts

@@ -13,7 +13,13 @@
  * All commands auto-detect the project root by looking for koguma.toml.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync
+} from 'fs';
 import { resolve, dirname, extname } from 'path';
 
 import { ANSI, log, ok, warn, fail, header } from './log.ts';
@@ -47,6 +53,7 @@ import {
   d1ExecuteBatchSqlAsync,
   r2PutLocal,
   r2PutLocalAsync,
+  r2PutRemoteAsync,
   wranglerDev,
   wranglerDeploy,
   createD1Database,
@@ -59,7 +66,11 @@ import {
   validateContent,
   type ContentTypeInfo
 } from './content.ts';
-import { startDevSync, DEV_SYNC_ENV_VAR, killStalePortHolder } from './dev-sync.ts';
+import {
+  startDevSync,
+  DEV_SYNC_ENV_VAR,
+  killStalePortHolder
+} from './dev-sync.ts';
 import { buildInsertSql, wrapForShell } from '../src/db/sql.ts';
 import { intro, outro, handleCancel, p, BRAND } from './ui.ts';
 
@@ -156,8 +167,12 @@ async function syncContentToLocalD1(
         f => !f.startsWith('.') && !f.startsWith('_')
       );
       const mimeTypes: Record<string, string> = {
-        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml'
       };
 
       for (const file of mediaFiles) {
@@ -167,15 +182,19 @@ async function syncContentToLocalD1(
 
         assetIdMap.set(file, id);
         mediaUploads.push({ filePath: resolve(mediaDir, file), key });
-        assetSql.push(buildInsertSql('assets', {
-          id,
-          data: JSON.stringify({
-            title: file,
-            url: `/api/media/${key}`,
-            content_type: mimeTypes[ext] ?? 'application/octet-stream',
-            width: null, height: null, file_size: null
+        assetSql.push(
+          buildInsertSql('assets', {
+            id,
+            data: JSON.stringify({
+              title: file,
+              url: `/api/media/${key}`,
+              content_type: mimeTypes[ext] ?? 'application/octet-stream',
+              width: null,
+              height: null,
+              file_size: null
+            })
           })
-        }));
+        );
       }
     }
 
@@ -184,8 +203,14 @@ async function syncContentToLocalD1(
     const entrySql: string[] = [];
     for (const { contentType, rowData } of prepared) {
       const {
-        id, slug, status, publish_at, publishAt,
-        created_at: _ca, updated_at: _ua, content_type: _ct,
+        id,
+        slug,
+        status,
+        publish_at,
+        publishAt,
+        created_at: _ca,
+        updated_at: _ua,
+        content_type: _ct,
         ...fields
       } = rowData;
 
@@ -193,9 +218,16 @@ async function syncContentToLocalD1(
       const ct = config.contentTypes.find(c => c.id === contentType);
       if (ct && assetIdMap.size > 0) {
         for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
-          if (meta.fieldType === 'image' && typeof fields[fieldId] === 'string') {
-            fields[fieldId] = assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
-          } else if (meta.fieldType === 'images' && Array.isArray(fields[fieldId])) {
+          if (
+            meta.fieldType === 'image' &&
+            typeof fields[fieldId] === 'string'
+          ) {
+            fields[fieldId] =
+              assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
+          } else if (
+            meta.fieldType === 'images' &&
+            Array.isArray(fields[fieldId])
+          ) {
             fields[fieldId] = (fields[fieldId] as string[]).map(
               v => assetIdMap.get(v) ?? v
             );
@@ -203,21 +235,26 @@ async function syncContentToLocalD1(
         }
       }
 
-      entrySql.push(buildInsertSql('entries', {
-        id: id as string,
-        content_type: contentType,
-        slug: (slug as string | undefined) ?? null,
-        data: JSON.stringify(fields),
-        status: (status as string | undefined) ?? 'draft',
-        ...(publish_at !== undefined ? { publish_at } : {}),
-        ...(publishAt !== undefined ? { publish_at: publishAt } : {})
-      }));
+      entrySql.push(
+        buildInsertSql('entries', {
+          id: id as string,
+          content_type: contentType,
+          slug: (slug as string | undefined) ?? null,
+          data: JSON.stringify(fields),
+          status: (status as string | undefined) ?? 'draft',
+          ...(publish_at !== undefined ? { publish_at } : {}),
+          ...(publishAt !== undefined ? { publish_at: publishAt } : {})
+        })
+      );
     }
 
     // Single batch: assets + entries written to one SQL file
     const allStatements = [...assetSql, ...entrySql];
     if (allStatements.length > 0) {
-      if (s) s.message(`Syncing ${entrySql.length} entries + ${assetSql.length} assets...`);
+      if (s)
+        s.message(
+          `Syncing ${entrySql.length} entries + ${assetSql.length} assets...`
+        );
       await d1ExecuteBatchSqlAsync(root, dbName, '--local', allStatements);
     }
 
@@ -542,7 +579,10 @@ async function cmdDev(): Promise<void> {
 /**
  * koguma push — Ship to production.
  *
- * Content sync → build admin → deploy → sync data + media to remote.
+ * Reads content/ directly as the source of truth:
+ *   - Entries + media metadata → remote D1  (no local D1 roundtrip)
+ *   - content/media/ files → remote R2  (no localhost dependency)
+ *   - Then builds and deploys the worker.
  */
 async function cmdPush(): Promise<void> {
   intro('push');
@@ -557,127 +597,178 @@ async function cmdPush(): Promise<void> {
 
   const { dbName, bucketName } = getProjectNames(root);
 
-  // ── Confirmation ──
-  const confirmed = await p.confirm({
-    message: `Push local content to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET}?`,
-    initialValue: true
-  });
-  if (handleCancel(confirmed)) return;
-  if (!confirmed) {
-    outro('Push cancelled.');
-    return;
+  // ── Confirmation (Enter = yes, n = cancel, --yes to skip) ──
+  const skipConfirm =
+    process.argv.includes('--yes') || process.argv.includes('-y');
+  if (!skipConfirm) {
+    const answer = await p.text({
+      message: `Push to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET}? (Y/n)`,
+      defaultValue: 'y',
+      placeholder: 'y'
+    });
+    if (handleCancel(answer)) return;
+    if ((answer as string).toLowerCase().startsWith('n')) {
+      outro('Push cancelled.');
+      return;
+    }
+  } else {
+    p.log.info(`Pushing to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET} (--yes)`);
   }
 
-  // ── Step 1: Apply schema to remote ──
+  // ── Step 1/4: Apply schema to remote ──
   const s1 = p.spinner();
   s1.start('Applying schema to remote...');
   applySchema(root, dbName, '--remote');
   s1.stop('Remote schema applied');
 
-  // ── Step 2: Sync content/ → local D1 ──
+  // ── Step 2/4: content/ → remote D1 (direct, no local roundtrip) ──
   const s2 = p.spinner();
-  s2.start('Syncing content/ to local D1...');
-  await syncContentToLocalD1(root, dbName, s2);
-  s2.stop('Local content synced');
-
-  // ── Step 3: Export local content ──
-  const s3 = p.spinner();
-  s3.start('Exporting local content...');
-
-  let localEntries: Record<string, unknown>[] = [];
-  try {
-    localEntries = d1Query(root, dbName, '--local', 'SELECT * FROM entries');
-  } catch {
-    p.log.warn('Could not export entries from local');
-  }
+  s2.start('Reading content/ and syncing to remote D1...');
+  const contentDir = resolve(root, CONTENT_DIR);
+  const mediaDir = resolve(contentDir, 'media');
+  let syncedEntries = 0;
+  let syncedAssets = 0;
 
-  let localAssets: Record<string, unknown>[] = [];
   try {
-    localAssets = d1Query(root, dbName, '--local', 'SELECT * FROM assets');
-  } catch {
-    p.log.warn('Could not export assets from local');
-  }
-  s3.stop(
-    `Exported ${localEntries.length} entries + ${localAssets.length} assets`
-  );
+    const config = await loadSiteConfig(root);
 
-  // ── Step 4: Import to remote ──
-  const total = localEntries.length + localAssets.length;
-  if (total > 0) {
-    const prog = p.progress({ max: total });
-    prog.start('Importing content to remote...');
+    // Build asset rows from content/media/ filenames
+    const mimeTypes: 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'
+    };
+    const assetIdMap = new Map<string, string>();
+    const allStatements: string[] = [];
 
-    let done = 0;
-    for (const asset of localAssets) {
-      d1InsertRow(root, dbName, '--remote', 'assets', asset);
-      done++;
-      prog.advance(done, `Importing... (${done}/${total})`);
-    }
-    for (const entry of localEntries) {
-      d1InsertRow(root, dbName, '--remote', 'entries', entry);
-      done++;
-      prog.advance(done, `Importing... (${done}/${total})`);
+    if (existsSync(mediaDir)) {
+      const mediaFiles = readdirSync(mediaDir).filter(
+        f => !f.startsWith('.') && !f.startsWith('_')
+      );
+      for (const file of mediaFiles) {
+        const ext = extname(file).toLowerCase();
+        const id = `media-${file.replace(/\.\w+$/, '')}`;
+        const key = `${id}${ext}`;
+        assetIdMap.set(file, id);
+        allStatements.push(
+          buildInsertSql('assets', {
+            id,
+            data: JSON.stringify({
+              title: file,
+              url: `/api/media/${key}`,
+              content_type: mimeTypes[ext] ?? 'application/octet-stream',
+              width: null,
+              height: null,
+              file_size: null
+            })
+          })
+        );
+      }
+      syncedAssets = assetIdMap.size;
     }
-    prog.stop(
-      `Synced ${localEntries.length} entries + ${localAssets.length} assets to remote`
-    );
-  }
 
-  // ── Step 5: Upload media to remote ──
-  if (localAssets.length > 0) {
-    const cookie = await authenticate(remoteUrl, root);
-    const sProg = p.progress({ max: localAssets.length });
-    sProg.start('Uploading media to remote...');
-
-    let uploaded = 0;
-    for (const asset of localAssets) {
-      const assetData =
-        typeof asset.data === 'string'
-          ? JSON.parse(asset.data)
-          : (asset.data as Record<string, string>);
-      const assetUrl = assetData.url ?? '';
-      const assetTitle = assetData.title ?? '';
-      const contentType = assetData.content_type ?? 'application/octet-stream';
-      const key = assetUrl.replace('/api/media/', '');
+    // Read content/ entries → build SQL
+    const prepared = prepareContentForSync(contentDir, config.contentTypes);
+    for (const { contentType, rowData } of prepared) {
+      const {
+        id,
+        slug,
+        status,
+        publish_at,
+        publishAt,
+        created_at: _ca,
+        updated_at: _ua,
+        content_type: _ct,
+        ...fields
+      } = rowData;
 
-      try {
-        const dlRes = await fetch(`http://localhost:8787${assetUrl}`);
-        if (!dlRes.ok) {
-          uploaded++;
-          sProg.advance(uploaded);
-          continue;
+      // Resolve media filenames → asset IDs
+      const ct = config.contentTypes.find(c => c.id === contentType);
+      if (ct && assetIdMap.size > 0) {
+        for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
+          if (
+            meta.fieldType === 'image' &&
+            typeof fields[fieldId] === 'string'
+          ) {
+            fields[fieldId] =
+              assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
+          } else if (
+            meta.fieldType === 'images' &&
+            Array.isArray(fields[fieldId])
+          ) {
+            fields[fieldId] = (fields[fieldId] as string[]).map(
+              v => assetIdMap.get(v) ?? v
+            );
+          }
         }
+      }
 
-        const blob = await dlRes.blob();
-        const formData = new FormData();
-        formData.append('file', new File([blob], key, { type: contentType }));
-        formData.append('title', assetTitle || key);
+      allStatements.push(
+        buildInsertSql('entries', {
+          id: id as string,
+          content_type: contentType,
+          slug: (slug as string | undefined) ?? null,
+          data: JSON.stringify(fields),
+          status: (status as string | undefined) ?? 'published',
+          ...(publish_at !== undefined ? { publish_at } : {}),
+          ...(publishAt !== undefined ? { publish_at: publishAt } : {})
+        })
+      );
+    }
+    syncedEntries = prepared.length;
 
-        const upRes = await fetch(`${remoteUrl}/api/admin/media`, {
-          method: 'POST',
-          headers: { Cookie: cookie },
-          body: formData
-        });
+    if (allStatements.length > 0) {
+      await d1ExecuteBatchSqlAsync(root, dbName, '--remote', allStatements);
+    }
+    s2.stop(
+      `Synced ${syncedEntries} entries + ${syncedAssets} assets to remote D1`
+    );
+  } catch (e) {
+    s2.stop('Content sync failed');
+    warn(`${e}`);
+  }
 
-        if (!upRes.ok) {
-          warn(`Upload failed for ${assetTitle}: ${await upRes.text()}`);
+  // ── Step 3/4: content/media/ → remote R2 (direct file upload) ──
+  if (existsSync(mediaDir)) {
+    const mediaFiles = readdirSync(mediaDir).filter(
+      f => !f.startsWith('.') && !f.startsWith('_')
+    );
+    if (mediaFiles.length > 0) {
+      const sProg = p.progress({ max: mediaFiles.length });
+      sProg.start('Uploading media files to remote R2...');
+      let uploaded = 0;
+      for (const file of mediaFiles) {
+        const ext = extname(file).toLowerCase();
+        const id = `media-${file.replace(/\.\w+$/, '')}`;
+        const key = `${id}${ext}`;
+        try {
+          await r2PutRemoteAsync(
+            root,
+            bucketName,
+            key,
+            resolve(mediaDir, file)
+          );
+        } catch (e) {
+          warn(`Failed to upload ${file}: ${e}`);
         }
-      } catch (e) {
-        warn(`Error uploading ${assetTitle}: ${e}`);
+        uploaded++;
+        sProg.advance(
+          uploaded,
+          `Uploading... (${uploaded}/${mediaFiles.length})`
+        );
       }
-      uploaded++;
-      sProg.advance(
-        uploaded,
-        `Uploading media... (${uploaded}/${localAssets.length})`
-      );
+      sProg.stop(`Uploaded ${uploaded} media files to remote R2`);
     }
-    sProg.stop(`Uploaded ${uploaded} media assets`);
   }
 
-  // ── Step 6: Build + Deploy ──
+  // ── Step 4/4: Build + Deploy ──
   const sBuild = p.spinner();
   sBuild.start('Building admin dashboard...');
-
   const kogumaRoot = findKogumaRoot();
   const adminDir = resolve(kogumaRoot, 'admin');
   if (existsSync(adminDir)) {
@@ -949,7 +1040,7 @@ function cmdHelp(): void {
     [
       `${BRAND.ACCENT}init${BRAND.RESET}            Set up a new project ${BRAND.DIM}(scaffold, login, D1, R2, secret)${BRAND.RESET}`,
       `${BRAND.ACCENT}dev${BRAND.RESET}             Start local dev server ${BRAND.DIM}with auto-sync + typegen${BRAND.RESET}`,
-      `${BRAND.ACCENT}push${BRAND.RESET}            Build, deploy, and sync content to remote`,
+      `${BRAND.ACCENT}push${BRAND.RESET}            Build, deploy, and sync content to remote ${BRAND.DIM}(--yes to skip confirm)${BRAND.RESET}`,
       `${BRAND.ACCENT}pull${BRAND.RESET}            Download remote content + media to local`,
       `${BRAND.ACCENT}gen-types${BRAND.RESET}       Generate ${BRAND.DIM}koguma.d.ts${BRAND.RESET} typed interfaces`,
       `${BRAND.ACCENT}tidy${BRAND.RESET}            Sync content/ dirs with config + validate`,
@@ -962,7 +1053,7 @@ function cmdHelp(): void {
     [
       `${BRAND.DIM}$${BRAND.RESET} koguma init`,
       `${BRAND.DIM}$${BRAND.RESET} koguma dev`,
-      `${BRAND.DIM}$${BRAND.RESET} koguma push --remote https://my-site.dev`,
+      `${BRAND.DIM}$${BRAND.RESET} koguma push --remote https://my-site.dev${BRAND.DIM} --yes${BRAND.RESET}`,
       `${BRAND.DIM}$${BRAND.RESET} koguma pull --remote https://my-site.dev`,
       `${BRAND.DIM}$${BRAND.RESET} koguma gen-types`,
       `${BRAND.DIM}$${BRAND.RESET} koguma tidy --dry`

package/cli/scaffold.ts

@@ -11,7 +11,11 @@ import {
 import { resolve } from 'path';
 import { ok, warn } from './log.ts';
 import { generateKogumaToml } from './config.ts';
-import { findMarkdownField, type ContentTypeInfo } from './content.ts';
+import {
+  findMarkdownField,
+  findMarkdownFields,
+  type ContentTypeInfo
+} from './content.ts';
 import matter from 'gray-matter';
 
 // ── Template types ─────────────────────────────────────────────────
@@ -315,29 +319,50 @@ export function generateExampleFile(
   ctId: string,
   fields: Record<string, { fieldType: string }>,
   singleton?: boolean
-): { content: string; extension: string } {
+): {
+  content: string;
+  extension: string;
+  siblingFiles?: { fieldId: string; content: string }[];
+} {
   const frontmatter: Record<string, unknown> = {};
-  let hasMarkdown = false;
+  const mdFields = Object.entries(fields)
+    .filter(([, meta]) => meta.fieldType === 'markdown')
+    .map(([id]) => id);
+  const primaryMdField = mdFields[0] ?? null;
+  const extraMdFields = mdFields.slice(1);
 
   for (const [fieldId, meta] of Object.entries(fields)) {
     if (meta.fieldType === 'markdown') {
-      hasMarkdown = true;
-      continue; // markdown goes in body, not frontmatter
+      continue; // markdown goes in body or sibling files, not frontmatter
     }
     frontmatter[fieldId] = placeholderForFieldType(meta.fieldType);
   }
 
-  if (hasMarkdown) {
+  // Build sibling example files for extra markdown fields
+  const siblingFiles: { fieldId: string; content: string }[] = [];
+  for (const fieldId of extraMdFields) {
+    siblingFiles.push({
+      fieldId,
+      content: `Write your ${fieldId} content here.`
+    });
+  }
+
+  if (primaryMdField) {
     const fm = matter.stringify('', frontmatter).trim();
     const bodyHint = singleton ? '' : `\nWrite your ${ctId} content here.\n`;
     return {
       content: `${fm}\n${bodyHint}`,
-      extension: '.md'
+      extension: '.md',
+      ...(siblingFiles.length > 0 ? { siblingFiles } : {})
     };
   }
 
   const fm = matter.stringify('', frontmatter).trim();
-  return { content: fm + '\n', extension: '.md' };
+  return {
+    content: fm + '\n',
+    extension: '.md',
+    ...(siblingFiles.length > 0 ? { siblingFiles } : {})
+  };
 }
 
 /**
@@ -367,7 +392,7 @@ export function scaffoldContentDirFromTemplate(
         fields[fid] = { fieldType: fieldTypeFromExpression(expr) };
       }
 
-      const { content, extension } = generateExampleFile(
+      const { content, extension, siblingFiles } = generateExampleFile(
         ct.id,
         fields,
         ct.singleton
@@ -375,6 +400,14 @@ export function scaffoldContentDirFromTemplate(
       const filename = `_example${extension}`;
       writeFileSync(resolve(typeDir, filename), content);
       ok(`Created content/${ct.id}/${filename}`);
+
+      // Write sibling example files for extra markdown fields
+      if (siblingFiles) {
+        for (const { fieldId, content: siblingContent } of siblingFiles) {
+          const siblingName = `_example.${fieldId}.md`;
+          writeFileSync(resolve(typeDir, siblingName), siblingContent + '\n');
+        }
+      }
     } else if (!dirExisted) {
       ok(`Created content/${ct.id}/`);
     }
@@ -408,7 +441,7 @@ export function scaffoldContentDir(
     const isEmpty = dirExisted ? readdirSync(typeDir).length === 0 : true;
 
     if (isEmpty) {
-      const { content, extension } = generateExampleFile(
+      const { content, extension, siblingFiles } = generateExampleFile(
         ct.id,
         ct.fieldMeta,
         ct.singleton
@@ -416,6 +449,14 @@ export function scaffoldContentDir(
       const filename = `_example${extension}`;
       writeFileSync(resolve(typeDir, filename), content);
       ok(`Created content/${ct.id}/${filename}`);
+
+      // Write sibling example files for extra markdown fields
+      if (siblingFiles) {
+        for (const { fieldId, content: siblingContent } of siblingFiles) {
+          const siblingName = `_example.${fieldId}.md`;
+          writeFileSync(resolve(typeDir, siblingName), siblingContent + '\n');
+        }
+      }
     } else if (!dirExisted) {
       ok(`Created content/${ct.id}/`);
     }
@@ -538,7 +579,7 @@ export function syncContentDirsWithConfig(
         mkdirSync(typeDir, { recursive: true });
       }
 
-      const { content, extension } = generateExampleFile(
+      const { content, extension, siblingFiles } = generateExampleFile(
         ct.id,
         ct.fieldMeta,
         ct.singleton
@@ -551,6 +592,14 @@ export function syncContentDirsWithConfig(
       if (!dryRun) {
         writeFileSync(resolve(typeDir, filename), content);
         ok(`Created content/${ct.id}/${filename}`);
+
+        // Write sibling example files for extra markdown fields
+        if (siblingFiles) {
+          for (const { fieldId, content: siblingContent } of siblingFiles) {
+            const siblingName = `_example.${fieldId}.md`;
+            writeFileSync(resolve(typeDir, siblingName), siblingContent + '\n');
+          }
+        }
       }
       continue;
     }
@@ -559,7 +608,7 @@ export function syncContentDirsWithConfig(
 
     // If dir is empty, create _example
     if (files.length === 0) {
-      const { content, extension } = generateExampleFile(
+      const { content, extension, siblingFiles } = generateExampleFile(
         ct.id,
         ct.fieldMeta,
         ct.singleton
@@ -572,6 +621,14 @@ export function syncContentDirsWithConfig(
       if (!dryRun) {
         writeFileSync(resolve(typeDir, filename), content);
         ok(`Created content/${ct.id}/${filename}`);
+
+        // Write sibling example files for extra markdown fields
+        if (siblingFiles) {
+          for (const { fieldId, content: siblingContent } of siblingFiles) {
+            const siblingName = `_example.${fieldId}.md`;
+            writeFileSync(resolve(typeDir, siblingName), siblingContent + '\n');
+          }
+        }
       }
       continue;
     }