cosmolo 0.3.9 → 0.4.0

package/README.md

@@ -24,6 +24,7 @@ a canonical "just add Markdown and go" story without asking you to leave.
 | Component in Markdown | Yes (.svx) | Yes (.mdx) | Yes | No |
 | Config-driven categories | Yes | No | No | No |
 | Headless CMS (JSON API) | Yes | Manual | Manual | Manual |
+| DB migration path | `migrate:db` | No | No | Manual |
 | Learning curve | SvelteKit only | Astro concepts | Vue + Nuxt | SvelteKit only |
 
 **Core principles:**
@@ -272,6 +273,71 @@ Prompts for key (slug), label, and description. Appends the new entry to `config
 
 ---
 
+## Database Migration
+
+When a file-based Cosmolo site outgrows Markdown — multiple writers, mobile editing,
+a growing team — `migrate:db` converts your content to a database without rewriting
+your application code.
+
+DB support is optional. File-based sites continue to work exactly as before.
+Migration is a one-time operation when you're ready to scale.
+
+```bash
+bunx cosmolo migrate:db
+```
+
+The command is interactive and offers three paths:
+
+| Option | Description |
+|---|---|
+| **1 — Export SQL files** | Generates `cosmolo-migration/*.sql` (CREATE TABLE + INSERT for all articles and categories). Works with any relational database. |
+| **2 — Execute directly** | Executes the same SQL against a local SQLite database. Set `DATABASE_URL=./mysite.db` before running. |
+| **3 — Drizzle + Cloudflare D1** | Full setup: generates Drizzle schema, CRUD helpers, `wrangler.toml` D1 binding, and `drizzle.config.ts`. Runs preflight checks before writing anything. |
+
+### What gets migrated
+
+- **Articles** — all frontmatter fields plus the raw Markdown body. Subdirectory-organized files (e.g. `articles/2024/post.md`) are handled automatically; the slug becomes `2024/post`.
+- **Categories** — from `config/categories.json`
+- **Draft articles** — included in the DB with `draft = 1`; the generated `getArticles()` helper filters them out automatically
+
+### Option 3 — Drizzle + Cloudflare D1
+
+After a preflight check (drizzle installed, wrangler.toml, table conflicts), the following files are generated:
+
+```
+drizzle/schema.ts            ← Drizzle schema for articles and categories tables
+src/lib/db/articles.ts       ← getArticles, getArticle, createArticle, updateArticle, deleteArticle
+src/lib/db/categories.ts     ← getCategories, getCategory, createCategory, updateCategory, deleteCategory
+wrangler.toml                ← [[d1_databases]] binding added (merged if file exists)
+drizzle.config.ts            ← drizzle-kit config (dialect: sqlite)
+.dev.vars.example            ← Cloudflare environment variable reference
+```
+
+The command prints step-by-step instructions after generation:
+1. `bunx wrangler d1 create <db-name>` and copy the `database_id` into `wrangler.toml`
+2. `bunx drizzle-kit generate` to create SQL migration files
+3. `bunx wrangler d1 migrations apply <db-name> --local` to apply locally
+4. Run Option 1 to export seed SQL, then `wrangler d1 execute` to import your articles
+5. `bun add -d @cloudflare/workers-types` for TypeScript support
+6. Add `interface Platform { env: { DB: D1Database } }` to `src/app.d.ts`
+
+### SSR requirement
+
+DB-backed content requires a server-capable adapter. Content in D1 is resolved at
+request time, so `adapter-static` (SSG) is not compatible.
+
+Switch to `adapter-cloudflare` for Cloudflare Pages, or `adapter-node` for a
+self-hosted server:
+
+```diff
+- import adapter from '@sveltejs/adapter-static';
++ import adapter from '@sveltejs/adapter-cloudflare';
+```
+
+The upside: content edits take effect immediately — no rebuild or redeploy needed.
+
+---
+
 ## Headless CMS
 
 Cosmolo can expose your content as static JSON endpoints, making it usable as a

package/dist/cli/index.js

@@ -7,6 +7,9 @@ switch (cmd) {
     case 'generate':
         await (await import('./generate.js')).main();
         break;
+    case 'migrate:db':
+        await (await import('./migrate.js')).main();
+        break;
     default: {
         const isUnknown = Boolean(cmd);
         if (isUnknown)
@@ -15,6 +18,7 @@ switch (cmd) {
         console.log('Commands:');
         console.log('  init                             Scaffold routes into an existing SvelteKit project');
         console.log('  generate [article|page|category] Create content files');
+        console.log('  migrate:db                       Migrate content to a database');
         process.exit(isUnknown ? 1 : 0);
     }
 }

package/dist/cli/migrate/drizzle-setup.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedCosmoloConfig } from '../../types.js';
+export declare function drizzleSetup(_config: ResolvedCosmoloConfig): Promise<void>;

package/dist/cli/migrate/drizzle-setup.js

@@ -0,0 +1,263 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { execSync } from 'child_process';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS } from './schema.js';
+// ─── readline helpers ─────────────────────────────────────────────────────────
+function ask(rl, question, fallback = '') {
+    const hint = fallback ? ` [${fallback}]` : '';
+    return new Promise((resolve) => rl.question(`  ${question}${hint}: `, (ans) => resolve(ans.trim() || fallback)));
+}
+function confirm(rl, question) {
+    return new Promise((resolve) => rl.question(`  ${question} [y/N] `, (ans) => resolve(ans.trim().toLowerCase() === 'y')));
+}
+// ─── Drizzle schema generation ────────────────────────────────────────────────
+function drizzleColumnDef(col) {
+    const fn = col.type === 'TEXT' ? 'text' : 'integer';
+    let chain = `  ${col.name}: ${fn}('${col.name}')`;
+    if (col.primaryKey) {
+        chain += '.primaryKey()';
+    }
+    else {
+        if (col.notNull)
+            chain += '.notNull()';
+        if (col.defaultValue !== undefined) {
+            const val = typeof col.defaultValue === 'string' ? `'${col.defaultValue}'` : col.defaultValue;
+            chain += `.default(${val})`;
+        }
+    }
+    return chain + ',';
+}
+function generateDrizzleSchema() {
+    const catCols = CATEGORY_COLUMNS.map(drizzleColumnDef).join('\n');
+    const artCols = ARTICLE_COLUMNS.map(drizzleColumnDef).join('\n');
+    return (`import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';\n\n` +
+        `export const categories = sqliteTable('categories', {\n${catCols}\n});\n\n` +
+        `export const articles = sqliteTable('articles', {\n${artCols}\n});\n`);
+}
+// ─── CRUD file generation ─────────────────────────────────────────────────────
+function generateArticlesCrud() {
+    return `import { drizzle } from 'drizzle-orm/d1';
+import { desc, eq } from 'drizzle-orm';
+import { articles } from '../../drizzle/schema';
+
+export function createDb(d1: D1Database) {
+  return drizzle(d1);
+}
+
+export async function getArticles(d1: D1Database) {
+  return createDb(d1)
+    .select()
+    .from(articles)
+    .where(eq(articles.draft, 0))
+    .orderBy(desc(articles.sort));
+}
+
+export async function getArticle(d1: D1Database, slug: string) {
+  const [row] = await createDb(d1).select().from(articles).where(eq(articles.slug, slug));
+  return row ?? null;
+}
+
+export async function createArticle(d1: D1Database, data: typeof articles.$inferInsert) {
+  return createDb(d1).insert(articles).values(data).returning();
+}
+
+export async function updateArticle(
+  d1: D1Database,
+  slug: string,
+  data: Partial<typeof articles.$inferInsert>
+) {
+  return createDb(d1).update(articles).set(data).where(eq(articles.slug, slug)).returning();
+}
+
+export async function deleteArticle(d1: D1Database, slug: string) {
+  return createDb(d1).delete(articles).where(eq(articles.slug, slug));
+}
+`;
+}
+function generateCategoriesCrud() {
+    return `import { drizzle } from 'drizzle-orm/d1';
+import { eq } from 'drizzle-orm';
+import { categories } from '../../drizzle/schema';
+
+export function createDb(d1: D1Database) {
+  return drizzle(d1);
+}
+
+export async function getCategories(d1: D1Database) {
+  return createDb(d1).select().from(categories);
+}
+
+export async function getCategory(d1: D1Database, key: string) {
+  const [row] = await createDb(d1).select().from(categories).where(eq(categories.key, key));
+  return row ?? null;
+}
+
+export async function createCategory(d1: D1Database, data: typeof categories.$inferInsert) {
+  return createDb(d1).insert(categories).values(data).returning();
+}
+
+export async function updateCategory(
+  d1: D1Database,
+  key: string,
+  data: Partial<typeof categories.$inferInsert>
+) {
+  return createDb(d1).update(categories).set(data).where(eq(categories.key, key)).returning();
+}
+
+export async function deleteCategory(d1: D1Database, key: string) {
+  return createDb(d1).delete(categories).where(eq(categories.key, key));
+}
+`;
+}
+function generateDrizzleConfig() {
+    return `import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './drizzle/schema.ts',
+  out: './drizzle/migrations',
+  dialect: 'sqlite',
+} satisfies Config;
+`;
+}
+function generateDevVarsExample() {
+    return `CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_DATABASE_ID=
+CLOUDFLARE_D1_TOKEN=
+`;
+}
+// ─── wrangler.toml helpers ────────────────────────────────────────────────────
+function d1Section(dbName) {
+    return (`\n[[d1_databases]]\n` +
+        `binding = "DB"\n` +
+        `database_name = "${dbName}"\n` +
+        `database_id = "REPLACE_WITH_YOUR_DATABASE_ID"\n`);
+}
+function updateWranglerToml(root, dbName) {
+    const wranglerPath = path.join(root, 'wrangler.toml');
+    if (fs.existsSync(wranglerPath)) {
+        const existing = fs.readFileSync(wranglerPath, 'utf-8');
+        fs.writeFileSync(wranglerPath, existing + d1Section(dbName));
+        return 'appended';
+    }
+    const minimal = `name = "cosmolo-site"\n` +
+        `compatibility_date = "2025-01-01"\n` +
+        d1Section(dbName);
+    fs.writeFileSync(wranglerPath, minimal);
+    return 'created';
+}
+// ─── preflight checks ─────────────────────────────────────────────────────────
+async function preflight(root, rl) {
+    console.log('\n  Checking environment...\n');
+    // drizzle-orm installed?
+    const drizzleInstalled = fs.existsSync(path.join(root, 'node_modules', 'drizzle-orm'));
+    if (!drizzleInstalled) {
+        console.log('  drizzle-orm is not installed.');
+        const install = await confirm(rl, 'Install drizzle-orm and drizzle-kit now?');
+        if (install) {
+            console.log('  Running: bun add drizzle-orm drizzle-kit ...');
+            execSync('bun add drizzle-orm drizzle-kit', { stdio: 'inherit', cwd: root });
+        }
+        else {
+            console.log('  Install drizzle-orm and drizzle-kit manually, then re-run migrate:db.');
+            return null;
+        }
+    }
+    // wrangler.toml: existing D1 binding?
+    const wranglerPath = path.join(root, 'wrangler.toml');
+    if (fs.existsSync(wranglerPath)) {
+        const content = fs.readFileSync(wranglerPath, 'utf-8');
+        if (content.includes('[[d1_databases]]')) {
+            console.log('  Warning: wrangler.toml already contains [[d1_databases]].');
+            const proceed = await confirm(rl, 'Add another D1 binding anyway?');
+            if (!proceed)
+                return null;
+        }
+    }
+    // drizzle/schema.ts exists?
+    const schemaPath = path.join(root, 'drizzle', 'schema.ts');
+    if (fs.existsSync(schemaPath)) {
+        const ok = await confirm(rl, 'drizzle/schema.ts already exists. Overwrite?');
+        if (!ok)
+            return null;
+        // table name conflict check
+        const existing = fs.readFileSync(schemaPath, 'utf-8');
+        const conflicts = ['articles', 'categories'].filter((t) => existing.includes(`sqliteTable('${t}'`));
+        if (conflicts.length > 0) {
+            console.log(`  Warning: table(s) already defined in schema: ${conflicts.join(', ')}`);
+            const ok2 = await confirm(rl, 'Continue and overwrite?');
+            if (!ok2)
+                return null;
+        }
+    }
+    // drizzle.config.ts exists?
+    const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+    if (fs.existsSync(drizzleConfigPath)) {
+        const ok = await confirm(rl, 'drizzle.config.ts already exists. Overwrite?');
+        if (!ok)
+            return null;
+    }
+    // src/lib/db/ CRUD files exist?
+    const dbDir = path.join(root, 'src', 'lib', 'db');
+    const crudFiles = ['articles.ts', 'categories.ts'].filter((f) => fs.existsSync(path.join(dbDir, f)));
+    if (crudFiles.length > 0) {
+        console.log(`  Warning: src/lib/db/${crudFiles.join(', ')} already exist.`);
+        const ok = await confirm(rl, 'Overwrite CRUD files?');
+        if (!ok)
+            return null;
+    }
+    // D1 database name
+    const dbName = await ask(rl, 'D1 database name', 'cosmolo');
+    return { dbName };
+}
+// ─── main ─────────────────────────────────────────────────────────────────────
+export async function drizzleSetup(_config) {
+    const root = process.cwd();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const result = await preflight(root, rl);
+    rl.close();
+    if (!result)
+        return;
+    const { dbName } = result;
+    // Generate drizzle/schema.ts
+    const drizzleDir = path.join(root, 'drizzle');
+    fs.mkdirSync(drizzleDir, { recursive: true });
+    fs.writeFileSync(path.join(drizzleDir, 'schema.ts'), generateDrizzleSchema());
+    // Generate src/lib/db/articles.ts and categories.ts
+    const dbDir = path.join(root, 'src', 'lib', 'db');
+    fs.mkdirSync(dbDir, { recursive: true });
+    fs.writeFileSync(path.join(dbDir, 'articles.ts'), generateArticlesCrud());
+    fs.writeFileSync(path.join(dbDir, 'categories.ts'), generateCategoriesCrud());
+    // drizzle.config.ts
+    fs.writeFileSync(path.join(root, 'drizzle.config.ts'), generateDrizzleConfig());
+    // .dev.vars.example
+    if (!fs.existsSync(path.join(root, '.dev.vars.example'))) {
+        fs.writeFileSync(path.join(root, '.dev.vars.example'), generateDevVarsExample());
+    }
+    // wrangler.toml
+    const wranglerAction = updateWranglerToml(root, dbName);
+    console.log('\n✓ Files generated:');
+    console.log('  drizzle/schema.ts');
+    console.log('  src/lib/db/articles.ts');
+    console.log('  src/lib/db/categories.ts');
+    console.log('  drizzle.config.ts');
+    console.log('  .dev.vars.example');
+    console.log(`  wrangler.toml  (${wranglerAction})`);
+    console.log('\nNext steps:\n');
+    console.log(`  1. Create the D1 database (if not done yet):`);
+    console.log(`       bunx wrangler d1 create ${dbName}`);
+    console.log(`     Copy the database_id into wrangler.toml.\n`);
+    console.log(`  2. Generate migration files:`);
+    console.log(`       bunx drizzle-kit generate\n`);
+    console.log(`  3. Apply migrations locally:`);
+    console.log(`       bunx wrangler d1 migrations apply ${dbName} --local\n`);
+    console.log(`  4. Seed content from Markdown files:`);
+    console.log(`       bunx cosmolo migrate:db  → choose Option 1 to export SQL`);
+    console.log(`       bunx wrangler d1 execute ${dbName} --local --file=cosmolo-migration/002_seed_categories.sql`);
+    console.log(`       bunx wrangler d1 execute ${dbName} --local --file=cosmolo-migration/003_seed_articles.sql\n`);
+    console.log(`  5. Install Cloudflare Workers types for TypeScript:`);
+    console.log(`       bun add -d @cloudflare/workers-types\n`);
+    console.log(`  6. Add D1Database to src/app.d.ts:`);
+    console.log(`       interface Platform { env: { DB: D1Database } }`);
+    console.log(`\n  See docs/DB_MIGRATION.md for full details.`);
+}

package/dist/cli/migrate/schema.d.ts

@@ -0,0 +1,12 @@
+export interface SqlColumn {
+    name: string;
+    type: 'TEXT' | 'INTEGER';
+    notNull: boolean;
+    defaultValue?: string | number;
+    primaryKey?: boolean;
+}
+export declare const ARTICLE_COLUMNS: SqlColumn[];
+export declare const CATEGORY_COLUMNS: SqlColumn[];
+export declare function createTableSql(tableName: string, columns: SqlColumn[]): string;
+export declare function escapeSql(val: string): string;
+export declare function toSqlLiteral(val: unknown): string;

package/dist/cli/migrate/schema.js

@@ -0,0 +1,56 @@
+// Derived from articleFrontmatterSchema in articles.ts.
+// Arrays are stored as JSON text. Booleans as INTEGER (0/1, SQLite convention).
+export const ARTICLE_COLUMNS = [
+    { name: 'slug', type: 'TEXT', notNull: true, primaryKey: true },
+    { name: 'title', type: 'TEXT', notNull: true },
+    { name: 'category', type: 'TEXT', notNull: true },
+    { name: 'excerpt', type: 'TEXT', notNull: true },
+    { name: 'sort', type: 'INTEGER', notNull: true, defaultValue: 0 },
+    { name: 'date', type: 'TEXT', notNull: true, defaultValue: '' },
+    { name: 'tags', type: 'TEXT', notNull: true, defaultValue: '[]' },
+    { name: 'series', type: 'TEXT', notNull: false },
+    { name: 'series_order', type: 'INTEGER', notNull: false },
+    { name: 'draft', type: 'INTEGER', notNull: true, defaultValue: 0 },
+    { name: 'related', type: 'TEXT', notNull: true, defaultValue: '[]' },
+    { name: 'body', type: 'TEXT', notNull: true },
+];
+export const CATEGORY_COLUMNS = [
+    { name: 'key', type: 'TEXT', notNull: true, primaryKey: true },
+    { name: 'label', type: 'TEXT', notNull: true },
+    { name: 'description', type: 'TEXT', notNull: true, defaultValue: '' },
+];
+function columnDef(col) {
+    let def = `  ${col.name} ${col.type}`;
+    if (col.primaryKey) {
+        def += ' PRIMARY KEY';
+    }
+    else {
+        if (col.notNull)
+            def += ' NOT NULL';
+        if (col.defaultValue !== undefined) {
+            const val = typeof col.defaultValue === 'string' ? `'${col.defaultValue}'` : col.defaultValue;
+            def += ` DEFAULT ${val}`;
+        }
+    }
+    return def;
+}
+export function createTableSql(tableName, columns) {
+    const defs = columns.map(columnDef).join(',\n');
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (\n${defs}\n);`;
+}
+export function escapeSql(val) {
+    return val.replace(/'/g, "''");
+}
+export function toSqlLiteral(val) {
+    if (val === null || val === undefined)
+        return 'NULL';
+    if (typeof val === 'boolean')
+        return val ? '1' : '0';
+    if (typeof val === 'number')
+        return String(val);
+    if (val instanceof Date)
+        return `'${escapeSql(val.toISOString().split('T')[0])}'`;
+    if (Array.isArray(val))
+        return `'${escapeSql(JSON.stringify(val))}'`;
+    return `'${escapeSql(String(val))}'`;
+}

package/dist/cli/migrate/sql-execute.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedCosmoloConfig } from '../../types.js';
+export declare function executeSqlDirect(config: ResolvedCosmoloConfig): Promise<void>;

package/dist/cli/migrate/sql-execute.js

@@ -0,0 +1,67 @@
+import * as path from 'path';
+import * as readline from 'readline';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS, createTableSql } from './schema.js';
+import { buildCategoriesInserts, buildArticlesInserts } from './sql-export.js';
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(`${question} [y/N] `, (ans) => {
+        rl.close();
+        resolve(ans.trim().toLowerCase() === 'y');
+    }));
+}
+function resolveDbPath(url) {
+    // Reject known non-SQLite URL schemes
+    if (/^(postgres|postgresql|mysql|mariadb|mongodb):\/\//i.test(url))
+        return null;
+    return url.replace(/^(sqlite:|file:)/, '');
+}
+export async function executeSqlDirect(config) {
+    const dbUrl = process.env.DATABASE_URL;
+    if (!dbUrl) {
+        console.error('\n  DATABASE_URL is not set.');
+        console.error('  Example: DATABASE_URL=./mysite.db bunx cosmolo migrate:db');
+        process.exit(1);
+    }
+    const dbPath = resolveDbPath(dbUrl);
+    if (!dbPath) {
+        console.error('\n  Only SQLite databases are supported for direct execution.');
+        console.error('  Use Option 1 to export SQL files for other database engines.');
+        process.exit(1);
+    }
+    const root = process.cwd();
+    const catInserts = buildCategoriesInserts(path.join(root, config.categoriesConfigPath));
+    const artInserts = buildArticlesInserts(path.join(root, config.articlesDir));
+    console.log(`\n  Target:     ${dbPath}`);
+    console.log(`  Categories: ${catInserts.length} rows`);
+    console.log(`  Articles:   ${artInserts.length} rows`);
+    const ok = await confirm('\n  Proceed?');
+    if (!ok) {
+        console.log('  Aborted.');
+        return;
+    }
+    // bun:sqlite is a bun built-in; the 'bun:' scheme is not a standard ESM URL
+    // so we suppress the TypeScript module resolution error here.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(dbPath);
+    try {
+        db.run('BEGIN TRANSACTION');
+        db.run(createTableSql('categories', CATEGORY_COLUMNS));
+        db.run(createTableSql('articles', ARTICLE_COLUMNS));
+        for (const sql of catInserts)
+            db.run(sql);
+        for (const sql of artInserts)
+            db.run(sql);
+        db.run('COMMIT');
+        console.log('\n  ✓ Migration complete.');
+    }
+    catch (err) {
+        db.run('ROLLBACK');
+        console.error('\n  Migration failed:', err);
+        process.exit(1);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/migrate/sql-export.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCosmoloConfig } from '../../types.js';
+export declare function buildCategoriesInserts(categoriesPath: string): string[];
+export declare function buildArticlesInserts(articlesDir: string): string[];
+export declare function exportSqlFiles(config: ResolvedCosmoloConfig): Promise<void>;

package/dist/cli/migrate/sql-export.js

@@ -0,0 +1,76 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS, createTableSql, escapeSql, toSqlLiteral, } from './schema.js';
+export function buildCategoriesInserts(categoriesPath) {
+    if (!fs.existsSync(categoriesPath))
+        return [];
+    const raw = JSON.parse(fs.readFileSync(categoriesPath, 'utf-8'));
+    return Object.entries(raw).map(([key, entry]) => {
+        const label = escapeSql(entry.label ?? '');
+        const description = escapeSql(entry.description ?? '');
+        return `INSERT INTO categories (key, label, description) VALUES ('${escapeSql(key)}', '${label}', '${description}');`;
+    });
+}
+function collectArticleFiles(dir, baseDir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectArticleFiles(fullPath, baseDir));
+        }
+        else if (/\.(md|svx)$/.test(entry.name)) {
+            const rel = path.relative(baseDir, fullPath).replace(/\.(md|svx)$/, '');
+            // Normalize path separators to forward slashes for slug
+            results.push({ filePath: fullPath, slug: rel.replace(/\\/g, '/') });
+        }
+    }
+    return results;
+}
+export function buildArticlesInserts(articlesDir) {
+    if (!fs.existsSync(articlesDir))
+        return [];
+    return collectArticleFiles(articlesDir, articlesDir).map(({ filePath, slug }) => {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { data, content } = matter(raw);
+        const dateVal = data.date instanceof Date
+            ? data.date.toISOString().split('T')[0]
+            : (data.date ?? '');
+        const values = [
+            toSqlLiteral(slug),
+            toSqlLiteral(data.title ?? ''),
+            toSqlLiteral(data.category ?? ''),
+            toSqlLiteral(data.excerpt ?? ''),
+            toSqlLiteral(data.sort ?? 0),
+            toSqlLiteral(dateVal),
+            toSqlLiteral(data.tags ?? []),
+            toSqlLiteral(data.series ?? null),
+            toSqlLiteral(data.seriesOrder ?? null),
+            toSqlLiteral(data.draft ?? false),
+            toSqlLiteral(data.related ?? []),
+            toSqlLiteral(content),
+        ].join(', ');
+        const cols = 'slug, title, category, excerpt, sort, date, tags, series, series_order, draft, related, body';
+        return `INSERT INTO articles (${cols}) VALUES (${values});`;
+    });
+}
+export async function exportSqlFiles(config) {
+    const root = process.cwd();
+    const outputDir = path.join(root, 'cosmolo-migration');
+    fs.mkdirSync(outputDir, { recursive: true });
+    const createSql = createTableSql('categories', CATEGORY_COLUMNS) +
+        '\n\n' +
+        createTableSql('articles', ARTICLE_COLUMNS);
+    fs.writeFileSync(path.join(outputDir, '001_create_tables.sql'), createSql + '\n');
+    const categoriesPath = path.join(root, config.categoriesConfigPath);
+    const catInserts = buildCategoriesInserts(categoriesPath);
+    fs.writeFileSync(path.join(outputDir, '002_seed_categories.sql'), catInserts.join('\n') + '\n');
+    const articlesDir = path.join(root, config.articlesDir);
+    const artInserts = buildArticlesInserts(articlesDir);
+    fs.writeFileSync(path.join(outputDir, '003_seed_articles.sql'), artInserts.join('\n') + '\n');
+    console.log(`\n✓ SQL files written to cosmolo-migration/`);
+    console.log('  001_create_tables.sql');
+    console.log(`  002_seed_categories.sql  (${catInserts.length} rows)`);
+    console.log(`  003_seed_articles.sql    (${artInserts.length} rows)`);
+    console.log('\nReview the files and run them against your database.');
+}

package/dist/cli/migrate.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/cli/migrate.js

@@ -0,0 +1,54 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_CONFIG } from '../config.js';
+async function loadConfig() {
+    const root = process.cwd();
+    for (const name of ['cosmolo.config.ts', 'cosmolo.config.js']) {
+        const p = path.join(root, name);
+        if (fs.existsSync(p)) {
+            try {
+                const mod = await import(p);
+                return mod.default;
+            }
+            catch {
+                // fall through to defaults
+            }
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+function ask(rl, question) {
+    return new Promise((resolve) => rl.question(question, (ans) => resolve(ans.trim())));
+}
+export async function main() {
+    const config = await loadConfig();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log('\ncosmolo migrate:db\n');
+    console.log('Select migration type:');
+    console.log('  1. Export as SQL files');
+    console.log('  2. Execute SQL directly');
+    console.log('  3. Full setup with Drizzle ORM + Cloudflare D1');
+    const choice = await ask(rl, '\n> ');
+    rl.close();
+    switch (choice) {
+        case '1': {
+            const { exportSqlFiles } = await import('./migrate/sql-export.js');
+            await exportSqlFiles(config);
+            break;
+        }
+        case '2': {
+            const { executeSqlDirect } = await import('./migrate/sql-execute.js');
+            await executeSqlDirect(config);
+            break;
+        }
+        case '3': {
+            const { drizzleSetup } = await import('./migrate/drizzle-setup.js');
+            await drizzleSetup(config);
+            break;
+        }
+        default:
+            console.error(`\nInvalid choice: "${choice}". Enter 1, 2, or 3.`);
+            process.exit(1);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cosmolo",
-	"version": "0.3.9",
+	"version": "0.4.0",
 	"type": "module",
 	"bin": {
 		"cosmolo": "./dist/cli/index.js"