@moxn/kb-migrate 0.4.18 → 0.4.20

package/dist/client.d.ts

@@ -53,9 +53,10 @@ export declare class MoxnClient {
      */
     addDatabaseColumn(databaseId: string, input: {
         name: string;
-        type: 'select' | 'multi_select';
+        type: 'select' | 'multi_select' | 'status' | 'checkbox' | 'number' | 'date' | 'text' | 'url' | 'email';
         optionTagIds?: string[];
         newOptionParentPath?: string;
+        config?: Record<string, unknown>;
     }): Promise<{
         id: string;
         name: string;
@@ -97,9 +98,10 @@ export declare class MoxnClient {
         columns: Array<{
             id: string;
             name: string;
-            type: 'select' | 'multi_select';
+            type: string;
             position: number;
             newOptionParentPath: string | null;
+            config?: Record<string, unknown> | null;
             options: Array<{
                 tagId: string;
                 tagName: string;
@@ -114,13 +116,21 @@ export declare class MoxnClient {
             properties: Record<string, {
                 columnId: string;
                 columnName: string;
-                columnType: 'select' | 'multi_select';
+                columnType: string;
                 values: Array<{
                     tagId: string;
                     tagName: string;
                     tagPath: string;
                     tagColor: string | null;
                 }>;
+            } | {
+                columnId: string;
+                columnName: string;
+                columnType: string;
+                textValue: string | null;
+                numberValue: number | null;
+                dateValue: string | null;
+                booleanValue: boolean | null;
             }>;
         }>;
     }>;
@@ -147,5 +157,9 @@ export declare class MoxnClient {
             id: string;
         };
     }>;
+    /**
+     * Set a scalar property value on a document in a database.
+     */
+    setPropertyValue(databaseId: string, documentId: string, columnName: string, value: string | number | boolean | null): Promise<void>;
     private isConflictError;
 }

package/dist/client.js

@@ -470,6 +470,23 @@ export class MoxnClient {
         }
         return response.json();
     }
+    /**
+     * Set a scalar property value on a document in a database.
+     */
+    async setPropertyValue(databaseId, documentId, columnName, value) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/databases/${databaseId}/properties`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify({ documentId, columnName, value }),
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to set property value: ${response.status}`);
+        }
+    }
     isConflictError(error) {
         return (error instanceof Error &&
             'documentId' in error &&

package/dist/export-notion.js

@@ -137,7 +137,12 @@ export async function runNotionExport(options) {
                     // Use the parent page ID as the target for database creation
                     const parentPageId = options.parentPageId;
                     const result = await exportDatabase(dbCtx, dbId, parentPageId);
-                    const icon = { created: '\u2713', updated: '\u21bb', skipped: '-', failed: '\u2717' }[result.status];
+                    const icon = {
+                        created: '\u2713',
+                        updated: '\u21bb',
+                        skipped: '-',
+                        failed: '\u2717',
+                    }[result.status];
                     console.log(`  ${icon} ${result.status}: ${result.kbDatabaseName} (${result.entriesCreated} entries)`);
                     if (result.error)
                         console.log(`    Error: ${result.error}`);
@@ -165,7 +170,8 @@ export async function runNotionExport(options) {
     // ============================================
     if (!options.dryRun) {
         // Find documents that have references and were successfully exported
-        const successfulExports = results.filter((r) => (r.status === 'created' || r.status === 'updated' || r.status === 'skipped') && r.externalId);
+        const successfulExports = results.filter((r) => (r.status === 'created' || r.status === 'updated' || r.status === 'skipped') &&
+            r.externalId);
         if (successfulExports.length > 0) {
             console.log(`\nPass 2: Resolving cross-references for ${successfulExports.length} documents...`);
             let totalResolved = 0;

package/dist/index.js

@@ -370,6 +370,9 @@ program
                     for (const col of dbImport.schema.mappedColumns) {
                         allPropertyTypes.add(col.notionType);
                     }
+                    for (const col of dbImport.schema.scalarColumns) {
+                        allPropertyTypes.add(col.notionType);
+                    }
                     for (const col of dbImport.schema.unmappedColumns) {
                         allPropertyTypes.add(col.notionType);
                     }
@@ -560,6 +563,24 @@ async function importNotionDatabase(client, dbImport, log, options, preCreatedDb
             console.warn(`    Warning: Failed to create column "${col.notionPropertyName}": ${error instanceof Error ? error.message : error}`);
         }
     }
+    // 2b. Create scalar columns (number, date, text, url, email)
+    const scalarColumnMap = new Map();
+    for (const col of schema.scalarColumns) {
+        try {
+            const column = await client.addDatabaseColumn(dbId, {
+                name: col.notionPropertyName,
+                type: col.moxnType,
+            });
+            scalarColumnMap.set(col.notionPropertyName, {
+                columnId: column.id,
+                moxnType: col.moxnType,
+            });
+            console.log(`    Column "${col.notionPropertyName}" (${col.moxnType})`);
+        }
+        catch (error) {
+            console.warn(`    Warning: Failed to create scalar column "${col.notionPropertyName}": ${error instanceof Error ? error.message : error}`);
+        }
+    }
     // 3. Link entries and assign tags
     // Build a map of KB path → { documentId, branchId } from migration results
     const docByPath = new Map();
@@ -605,6 +626,35 @@ async function importNotionDatabase(client, dbImport, log, options, preCreatedDb
                     }
                 }
             }
+            // Set scalar property values
+            for (const [colName, scalarVal] of values.scalarValues) {
+                const scalarColInfo = scalarColumnMap.get(colName);
+                if (!scalarColInfo)
+                    continue;
+                // Determine the value to send based on type
+                let value = null;
+                switch (scalarVal.moxnType) {
+                    case 'number':
+                        value = scalarVal.numberValue ?? null;
+                        break;
+                    case 'date':
+                        value = scalarVal.dateValue ?? null;
+                        break;
+                    case 'text':
+                    case 'url':
+                    case 'email':
+                        value = scalarVal.textValue ?? null;
+                        break;
+                }
+                if (value != null) {
+                    try {
+                        await client.setPropertyValue(dbId, docInfo.documentId, colName, value);
+                    }
+                    catch (error) {
+                        console.warn(`    Warning: Failed to set "${colName}" on ${docInfo.documentId}: ${error instanceof Error ? error.message : error}`);
+                    }
+                }
+            }
         }
         catch (error) {
             console.warn(`    Warning: Failed to link entry to database: ${error instanceof Error ? error.message : error}`);

package/dist/sources/notion-api.d.ts

@@ -129,6 +129,7 @@ export interface NotionPropertySchema {
         groups: Array<{
             id: string;
             name: string;
+            color?: string;
             option_ids: string[];
         }>;
     };

package/dist/sources/notion-databases.d.ts

@@ -8,17 +8,30 @@
  */
 import type { ContentBlock, SectionInput } from '../types.js';
 import type { NotionDatabase, NotionPage } from './notion-api.js';
-/** Parsed Notion column that maps to a Moxn DB column. */
+/** Parsed Notion column that maps to a Moxn tag-based DB column. */
 export interface MappedColumn {
     notionPropertyId: string;
     notionPropertyName: string;
-    notionType: 'select' | 'multi_select' | 'status';
-    moxnType: 'select' | 'multi_select';
+    notionType: 'select' | 'multi_select' | 'status' | 'checkbox';
+    moxnType: 'select' | 'multi_select' | 'status' | 'checkbox';
     options: Array<{
         notionId: string;
         name: string;
         color: string;
     }>;
+    /** Status group metadata (only for status columns). */
+    groups?: Array<{
+        name: string;
+        color: string;
+        optionNames: string[];
+    }>;
+}
+/** Parsed Notion column that maps to a Moxn scalar DB column. */
+export interface ScalarColumn {
+    notionPropertyId: string;
+    notionPropertyName: string;
+    notionType: 'number' | 'date' | 'url' | 'email' | 'rich_text' | 'checkbox';
+    moxnType: 'number' | 'date' | 'url' | 'email' | 'text';
 }
 /** Parsed Notion column that will be rendered as text in a Properties section. */
 export interface UnmappedColumn {
@@ -31,14 +44,26 @@ export interface ParsedDatabaseSchema {
     name: string;
     description: string;
     mappedColumns: MappedColumn[];
+    scalarColumns: ScalarColumn[];
     unmappedColumns: UnmappedColumn[];
 }
+/** Scalar value for a single database entry property. */
+export interface ScalarValue {
+    columnName: string;
+    moxnType: 'number' | 'date' | 'url' | 'email' | 'text';
+    textValue?: string | null;
+    numberValue?: number | null;
+    dateValue?: string | null;
+    booleanValue?: boolean | null;
+}
 /** Parsed property values for a single database entry. */
 export interface ParsedEntryValues {
     /** Document name derived from title property. */
     title: string;
     /** Mapped column values: column name → selected option names. */
     tagValues: Map<string, string[]>;
+    /** Scalar property values: column name → scalar value. */
+    scalarValues: Map<string, ScalarValue>;
     /** Unmapped property values for markdown table: property name → rendered value. */
     textValues: Map<string, string>;
     /** File attachments to include as content blocks. */

package/dist/sources/notion-databases.js

@@ -17,6 +17,7 @@ export function parseDatabaseSchema(db) {
     const name = richTextToPlain(db.title) || 'Untitled Database';
     const description = richTextToPlain(db.description);
     const mappedColumns = [];
+    const scalarColumns = [];
     const unmappedColumns = [];
     for (const [propName, prop] of Object.entries(db.properties)) {
         // Skip title — it becomes the document name
@@ -49,17 +50,77 @@ export function parseDatabaseSchema(db) {
             });
         }
         else if (prop.type === 'status' && prop.status) {
-            // Status is structurally identical to select
+            // Status → Moxn status column with group metadata
             mappedColumns.push({
                 notionPropertyId: prop.id,
                 notionPropertyName: propName,
                 notionType: 'status',
-                moxnType: 'select',
+                moxnType: 'status',
                 options: prop.status.options.map((o) => ({
                     notionId: o.id,
                     name: o.name,
                     color: o.color,
                 })),
+                groups: prop.status.groups?.map((g) => ({
+                    name: g.name,
+                    color: g.color ?? 'default',
+                    optionNames: g.option_ids
+                        ? g.option_ids.map((id) => prop.status.options.find((o) => o.id === id)?.name ?? id)
+                        : [],
+                })),
+            });
+        }
+        else if (prop.type === 'checkbox') {
+            // Checkbox → Moxn checkbox column (tag-based 2-option select)
+            mappedColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'checkbox',
+                moxnType: 'checkbox',
+                options: [
+                    { notionId: 'checked', name: 'Checked', color: 'green' },
+                    { notionId: 'unchecked', name: 'Unchecked', color: 'gray' },
+                ],
+            });
+        }
+        else if (prop.type === 'number') {
+            scalarColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'number',
+                moxnType: 'number',
+            });
+        }
+        else if (prop.type === 'date') {
+            scalarColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'date',
+                moxnType: 'date',
+            });
+        }
+        else if (prop.type === 'url') {
+            scalarColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'url',
+                moxnType: 'url',
+            });
+        }
+        else if (prop.type === 'email') {
+            scalarColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'email',
+                moxnType: 'email',
+            });
+        }
+        else if (prop.type === 'rich_text') {
+            scalarColumns.push({
+                notionPropertyId: prop.id,
+                notionPropertyName: propName,
+                notionType: 'rich_text',
+                moxnType: 'text',
             });
         }
         else {
@@ -74,7 +135,7 @@ export function parseDatabaseSchema(db) {
             });
         }
     }
-    return { name, description, mappedColumns, unmappedColumns };
+    return { name, description, mappedColumns, scalarColumns, unmappedColumns };
 }
 // ============================================
 // Entry Parsing
@@ -85,20 +146,38 @@ export function parseDatabaseSchema(db) {
 export function parseEntryValues(page, schema) {
     const title = getPageTitle(page);
     const tagValues = new Map();
+    const scalarValues = new Map();
     const textValues = new Map();
     const fileBlocks = [];
     // Build lookup by property name
     const mappedByName = new Map(schema.mappedColumns.map((c) => [c.notionPropertyName, c]));
+    const scalarByName = new Map(schema.scalarColumns.map((c) => [c.notionPropertyName, c]));
     const unmappedByName = new Set(schema.unmappedColumns.map((c) => c.notionPropertyName));
     for (const [propName, propValue] of Object.entries(page.properties)) {
         if (propValue.type === 'title')
             continue; // Already extracted
-        // Check if this is a mapped column
+        // Check if this is a tag-based mapped column
         const mapped = mappedByName.get(propName);
         if (mapped) {
-            const values = extractSelectValues(propValue, mapped.notionType);
-            if (values.length > 0) {
-                tagValues.set(propName, values);
+            // Checkbox uses tag-based approach: extract "Checked"/"Unchecked" option name
+            if (mapped.moxnType === 'checkbox') {
+                const isChecked = propValue.checkbox === true;
+                tagValues.set(propName, [isChecked ? 'Checked' : 'Unchecked']);
+            }
+            else {
+                const values = extractSelectValues(propValue, mapped.notionType);
+                if (values.length > 0) {
+                    tagValues.set(propName, values);
+                }
+            }
+            continue;
+        }
+        // Check if this is a scalar column
+        const scalar = scalarByName.get(propName);
+        if (scalar) {
+            const extracted = extractScalarValue(propValue, scalar);
+            if (extracted) {
+                scalarValues.set(propName, extracted);
             }
             continue;
         }
@@ -147,7 +226,7 @@ export function parseEntryValues(page, schema) {
             }
         }
     }
-    return { title, tagValues, textValues, fileBlocks };
+    return { title, tagValues, scalarValues, textValues, fileBlocks };
 }
 /**
  * Render unmapped properties as a markdown table section.
@@ -187,6 +266,54 @@ function extractSelectValues(propValue, notionType) {
             return [];
     }
 }
+function extractScalarValue(propValue, scalarCol) {
+    switch (scalarCol.moxnType) {
+        case 'number':
+            if (propValue.number == null)
+                return null;
+            return {
+                columnName: scalarCol.notionPropertyName,
+                moxnType: 'number',
+                numberValue: propValue.number,
+            };
+        case 'date':
+            if (!propValue.date?.start)
+                return null;
+            return {
+                columnName: scalarCol.notionPropertyName,
+                moxnType: 'date',
+                dateValue: propValue.date.start,
+            };
+        case 'url':
+            if (!propValue.url)
+                return null;
+            return {
+                columnName: scalarCol.notionPropertyName,
+                moxnType: 'url',
+                textValue: propValue.url,
+            };
+        case 'email':
+            if (!propValue.email)
+                return null;
+            return {
+                columnName: scalarCol.notionPropertyName,
+                moxnType: 'email',
+                textValue: propValue.email,
+            };
+        case 'text': {
+            const text = richTextToPlain(propValue.rich_text ?? []);
+            if (!text)
+                return null;
+            return {
+                columnName: scalarCol.notionPropertyName,
+                moxnType: 'text',
+                textValue: text,
+            };
+        }
+        default:
+            return null;
+    }
+}
 function renderPropertyValue(prop) {
     switch (prop.type) {
         case 'rich_text':

package/dist/sources/notion-databases.test.js

@@ -41,6 +41,7 @@ function makeSchema(unmappedColumns) {
         name: 'Test DB',
         description: '',
         mappedColumns: [],
+        scalarColumns: [],
         unmappedColumns: unmappedColumns.map((name) => ({
             notionPropertyId: `prop-${name}`,
             notionPropertyName: name,

package/dist/targets/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Target registry and factory
  */
-export { ExportTarget, type ExportTargetConfig, type ExportTargetResult, type ExportTargetLog } from './base.js';
+export { ExportTarget, type ExportTargetConfig, type ExportTargetResult, type ExportTargetLog, } from './base.js';
 export { NotionExportTarget, type NotionExportConfig } from './notion.js';
-export { exportDatabase, type DatabaseExportResult, type DatabaseExportContext } from './notion-database-export.js';
+export { exportDatabase, type DatabaseExportResult, type DatabaseExportContext, } from './notion-database-export.js';

package/dist/targets/index.js

@@ -1,6 +1,6 @@
 /**
  * Target registry and factory
  */
-export { ExportTarget } from './base.js';
+export { ExportTarget, } from './base.js';
 export { NotionExportTarget } from './notion.js';
-export { exportDatabase } from './notion-database-export.js';
+export { exportDatabase, } from './notion-database-export.js';

package/dist/targets/notion-database-export.js

@@ -28,7 +28,7 @@ const HEX_TO_NOTION_COLOR = {
 function hexToNotionColor(hex) {
     if (!hex)
         return 'default';
-    return HEX_TO_NOTION_COLOR[hex.toUpperCase()] ?? HEX_TO_NOTION_COLOR[hex] ?? 'default';
+    return (HEX_TO_NOTION_COLOR[hex.toUpperCase()] ?? HEX_TO_NOTION_COLOR[hex] ?? 'default');
 }
 /**
  * Export a single KB database to Notion.
@@ -130,17 +130,62 @@ async function createNotionDatabase(ctx, parentPageId, resolved) {
             name: opt.tagName,
             color: hexToNotionColor(opt.tagColor),
         }));
-        if (col.type === 'select') {
-            properties[col.name] = {
-                type: 'select',
-                select: { options },
-            };
-        }
-        else if (col.type === 'multi_select') {
-            properties[col.name] = {
-                type: 'multi_select',
-                multi_select: { options },
-            };
+        switch (col.type) {
+            case 'select':
+                properties[col.name] = {
+                    type: 'select',
+                    select: { options },
+                };
+                break;
+            case 'multi_select':
+                properties[col.name] = {
+                    type: 'multi_select',
+                    multi_select: { options },
+                };
+                break;
+            case 'status':
+                // Status exports as select in Notion (status requires specific API access)
+                properties[col.name] = {
+                    type: 'select',
+                    select: { options },
+                };
+                break;
+            case 'checkbox':
+                properties[col.name] = {
+                    type: 'checkbox',
+                    checkbox: {},
+                };
+                break;
+            case 'number':
+                properties[col.name] = {
+                    type: 'number',
+                    number: { format: 'number' },
+                };
+                break;
+            case 'date':
+                properties[col.name] = {
+                    type: 'date',
+                    date: {},
+                };
+                break;
+            case 'url':
+                properties[col.name] = {
+                    type: 'url',
+                    url: {},
+                };
+                break;
+            case 'email':
+                properties[col.name] = {
+                    type: 'email',
+                    email: {},
+                };
+                break;
+            case 'text':
+                properties[col.name] = {
+                    type: 'rich_text',
+                    rich_text: {},
+                };
+                break;
         }
     }
     await sleep(RATE_LIMIT_MS);
@@ -216,19 +261,81 @@ async function createDatabaseEntries(ctx, dataSourceId, resolved) {
             };
             // Add column values
             for (const [colName, propValue] of Object.entries(doc.properties)) {
-                if (propValue.values.length === 0)
-                    continue;
-                if (propValue.columnType === 'select') {
-                    properties[colName] = {
-                        type: 'select',
-                        select: { name: propValue.values[0].tagName },
-                    };
+                // Tag-based columns (select, multi_select, status, checkbox)
+                if ('values' in propValue) {
+                    if (propValue.values.length === 0)
+                        continue;
+                    switch (propValue.columnType) {
+                        case 'select':
+                        case 'status':
+                            properties[colName] = {
+                                type: 'select',
+                                select: { name: propValue.values[0].tagName },
+                            };
+                            break;
+                        case 'multi_select':
+                            properties[colName] = {
+                                type: 'multi_select',
+                                multi_select: propValue.values.map((v) => ({ name: v.tagName })),
+                            };
+                            break;
+                        case 'checkbox': {
+                            // The first tag is the "checked" option
+                            const isChecked = propValue.values[0]?.tagName === 'Checked';
+                            properties[colName] = {
+                                type: 'checkbox',
+                                checkbox: isChecked,
+                            };
+                            break;
+                        }
+                    }
                 }
-                else if (propValue.columnType === 'multi_select') {
-                    properties[colName] = {
-                        type: 'multi_select',
-                        multi_select: propValue.values.map((v) => ({ name: v.tagName })),
-                    };
+                else {
+                    // Scalar columns (number, date, text, url, email)
+                    if (propValue.textValue == null && propValue.numberValue == null && propValue.dateValue == null && propValue.booleanValue == null)
+                        continue;
+                    switch (propValue.columnType) {
+                        case 'number':
+                            if (propValue.numberValue != null) {
+                                properties[colName] = {
+                                    type: 'number',
+                                    number: propValue.numberValue,
+                                };
+                            }
+                            break;
+                        case 'date':
+                            if (propValue.dateValue) {
+                                properties[colName] = {
+                                    type: 'date',
+                                    date: { start: propValue.dateValue },
+                                };
+                            }
+                            break;
+                        case 'url':
+                            if (propValue.textValue) {
+                                properties[colName] = {
+                                    type: 'url',
+                                    url: propValue.textValue,
+                                };
+                            }
+                            break;
+                        case 'email':
+                            if (propValue.textValue) {
+                                properties[colName] = {
+                                    type: 'email',
+                                    email: propValue.textValue,
+                                };
+                            }
+                            break;
+                        case 'text':
+                            if (propValue.textValue) {
+                                properties[colName] = {
+                                    type: 'rich_text',
+                                    rich_text: [{ type: 'text', text: { content: propValue.textValue } }],
+                                };
+                            }
+                            break;
+                    }
                 }
             }
             await sleep(RATE_LIMIT_MS);

package/dist/targets/notion.js

@@ -196,7 +196,6 @@ async function uploadFileToNotion(client, url, filename, contentType) {
  */
 function reconstructCallouts(blocks) {
     const emojiPrefixRe = /^(\p{Emoji_Presentation}|\p{Emoji}\uFE0F?)\s/u;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return blocks.map((block) => {
         // Case 1: paragraph with emoji prefix
         if (block.type === 'paragraph') {
@@ -214,7 +213,7 @@ function reconstructCallouts(blocks) {
             const calloutRichText = [
                 { ...firstSegment, text: { ...firstSegment.text, content: strippedContent } },
                 ...richText.slice(1),
-            ].filter((rt) => rt.text?.content);
+            ].filter((rt) => 'text' in rt && rt.text?.content);
             return {
                 object: 'block',
                 type: 'callout',
@@ -311,7 +310,11 @@ async function sectionsToNotionBlocks(sections, options) {
                 for (let i = 0; i < parts.length; i++) {
                     if (i > 0) {
                         flushText();
-                        allBlocks.push({ object: 'block', type: 'divider', divider: {} });
+                        allBlocks.push({
+                            object: 'block',
+                            type: 'divider',
+                            divider: {},
+                        });
                     }
                     const part = parts[i];
                     if (part.trim()) {
@@ -323,9 +326,12 @@ async function sectionsToNotionBlocks(sections, options) {
             else if (block.blockType === 'image' && block.url) {
                 flushText();
                 if (block.storageKey && options?.notionClient) {
-                    const fname = block.filename || deriveFilename(block.storageKey, block.mimeType || 'image/png');
+                    const fname = block.filename ||
+                        deriveFilename(block.storageKey, block.mimeType || 'image/png');
                     const uploadId = await uploadFileToNotion(options.notionClient, block.url, fname, block.mimeType || 'image/png');
-                    allBlocks.push(uploadId ? notionImageUploadBlock(uploadId, block.alt) : notionImageBlock(block.url, block.alt));
+                    allBlocks.push(uploadId
+                        ? notionImageUploadBlock(uploadId, block.alt)
+                        : notionImageBlock(block.url, block.alt));
                 }
                 else {
                     allBlocks.push(notionImageBlock(block.url, block.alt));
@@ -334,10 +340,13 @@ async function sectionsToNotionBlocks(sections, options) {
             else if (block.blockType === 'document' && block.url) {
                 flushText();
                 if (block.storageKey && options?.notionClient) {
-                    const fname = block.filename || deriveFilename(block.storageKey, block.mimeType || 'application/octet-stream');
+                    const fname = block.filename ||
+                        deriveFilename(block.storageKey, block.mimeType || 'application/octet-stream');
                     const uploadId = await uploadFileToNotion(options.notionClient, block.url, fname, block.mimeType || 'application/octet-stream');
                     if (uploadId) {
-                        allBlocks.push(block.mimeType === 'application/pdf' ? notionPdfUploadBlock(uploadId, block.filename) : notionFileUploadBlock(uploadId, block.filename));
+                        allBlocks.push(block.mimeType === 'application/pdf'
+                            ? notionPdfUploadBlock(uploadId, block.filename)
+                            : notionFileUploadBlock(uploadId, block.filename));
                     }
                     else if (block.mimeType === 'application/pdf') {
                         allBlocks.push(notionPdfBlock(block.url, block.filename));
@@ -358,7 +367,9 @@ async function sectionsToNotionBlocks(sections, options) {
                 if (block.storageKey && options?.notionClient) {
                     const fname = block.filename || deriveFilename(block.storageKey, 'text/csv');
                     const uploadId = await uploadFileToNotion(options.notionClient, block.url, fname, 'text/csv');
-                    allBlocks.push(uploadId ? notionFileUploadBlock(uploadId, block.filename || 'data.csv') : notionFileBlock(block.url, block.filename || 'data.csv'));
+                    allBlocks.push(uploadId
+                        ? notionFileUploadBlock(uploadId, block.filename || 'data.csv')
+                        : notionFileBlock(block.url, block.filename || 'data.csv'));
                 }
                 else {
                     allBlocks.push(notionFileBlock(block.url, block.filename || 'data.csv'));
@@ -453,7 +464,9 @@ export class NotionExportTarget extends ExportTarget {
      */
     async resolveAndAppendReferences(doc, notionPageId) {
         // Extract references from section content (no upload needed for reference pass)
-        const { references } = await sectionsToNotionBlocks(doc.sections, { extractReferences: true });
+        const { references } = await sectionsToNotionBlocks(doc.sections, {
+            extractReferences: true,
+        });
         if (references.length === 0) {
             return { resolved: 0, unresolved: 0 };
         }
@@ -623,7 +636,10 @@ export class NotionExportTarget extends ExportTarget {
     // Notion page creation / update
     // ============================================
     async createNotionPage(doc) {
-        const { blocks } = await sectionsToNotionBlocks(doc.sections, { extractReferences: true, notionClient: this.client });
+        const { blocks } = await sectionsToNotionBlocks(doc.sections, {
+            extractReferences: true,
+            notionClient: this.client,
+        });
         // First batch: up to 100 blocks as children of the new page
         const firstBatch = blocks.slice(0, MAX_BLOCKS_PER_APPEND);
         const remainingBlocks = blocks.slice(MAX_BLOCKS_PER_APPEND);
@@ -655,7 +671,10 @@ export class NotionExportTarget extends ExportTarget {
             },
         });
         await this.clearPageContent(notionPageId);
-        const { blocks } = await sectionsToNotionBlocks(doc.sections, { extractReferences: true, notionClient: this.client });
+        const { blocks } = await sectionsToNotionBlocks(doc.sections, {
+            extractReferences: true,
+            notionClient: this.client,
+        });
         await this.appendRemainingBlocks(notionPageId, blocks);
     }
     async clearPageContent(pageId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxn/kb-migrate",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "description": "Migration tool for importing documents into Moxn Knowledge Base from local files, Notion, Google Docs, and more",
   "type": "module",
   "main": "dist/index.js",