@moxn/kb-migrate 0.4.19 → 0.4.21

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;
@@ -71,6 +72,7 @@ export declare class MoxnClient {
         path: string;
         description?: string;
         color?: string;
+        displayName?: string;
     }): Promise<{
         id: string;
         path: string;
@@ -80,6 +82,20 @@ export declare class MoxnClient {
      * Assign a tag to a document.
      */
     assignTag(documentId: string, tagId: string, branchId: string): Promise<void>;
+    /**
+     * Batch-create references from a document's sections to other documents.
+     * Returns { created, skipped, errors }.
+     */
+    createReferences(documentId: string, references: Array<{
+        sourceSectionId: string;
+        branchId: string;
+        targetDocumentId: string;
+        displayTitle?: string | null;
+    }>): Promise<{
+        created: number;
+        skipped: number;
+        errors: number;
+    }>;
     /**
      * List all KB databases for the tenant.
      */
@@ -97,9 +113,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 +131,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 +172,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

@@ -51,6 +51,9 @@ export class MoxnClient {
                 documentId: createResult.id,
                 branchId: createResult.branchId,
                 sectionsCount: createResult.sections.length,
+                sectionIds: createResult.sections.map((s) => s.id),
+                references: doc.references,
+                sourcePageId: doc.metadata?.notionPageId,
                 duration: Date.now() - startTime,
             };
         }
@@ -82,6 +85,9 @@ export class MoxnClient {
                         documentId: updateResult.id,
                         branchId: updateResult.branchId,
                         sectionsCount: updateResult.sections.length,
+                        sectionIds: updateResult.sections.map((s) => s.id),
+                        references: doc.references,
+                        sourcePageId: doc.metadata?.notionPageId,
                         duration: Date.now() - startTime,
                     };
                 }
@@ -414,6 +420,25 @@ export class MoxnClient {
             throw new Error(body.error || `Failed to assign tag: ${response.status}`);
         }
     }
+    /**
+     * Batch-create references from a document's sections to other documents.
+     * Returns { created, skipped, errors }.
+     */
+    async createReferences(documentId, references) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/documents/${documentId}/references`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify({ references }),
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to create references: ${response.status}`);
+        }
+        return response.json();
+    }
     /**
      * List all KB databases for the tenant.
      */
@@ -470,6 +495,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/index.js

@@ -140,6 +140,85 @@ function printNotionExportSummary(log) {
         console.log('\n(Dry run - no changes made)');
     }
 }
+/**
+ * Resolve cross-references after migration.
+ *
+ * Builds a notionId → { documentId, branchId, sectionIds } mapping from results,
+ * then creates KB Reference objects for each extracted cross-reference.
+ */
+async function resolveReferences(client, results) {
+    // Build notionId → document info mapping
+    const notionIdMap = new Map();
+    for (const result of results) {
+        if (result.sourcePageId &&
+            result.documentId &&
+            result.branchId &&
+            result.sectionIds &&
+            (result.status === 'created' || result.status === 'updated')) {
+            notionIdMap.set(result.sourcePageId, {
+                documentId: result.documentId,
+                branchId: result.branchId,
+                sectionIds: result.sectionIds,
+            });
+        }
+    }
+    let totalCreated = 0;
+    let totalSkipped = 0;
+    let totalErrors = 0;
+    let unresolvedTargets = 0;
+    let invalidSectionIndexes = 0;
+    for (const result of results) {
+        if (!result.references?.length ||
+            !result.documentId ||
+            !result.branchId ||
+            !result.sectionIds) {
+            continue;
+        }
+        if (result.status !== 'created' && result.status !== 'updated') {
+            continue;
+        }
+        const refs = [];
+        for (const ref of result.references) {
+            // Resolve target Notion ID → Moxn document ID
+            const target = notionIdMap.get(ref.targetNotionId);
+            if (!target) {
+                unresolvedTargets++;
+                continue;
+            }
+            // Map sectionIndex → sourceSectionId
+            const sourceSectionId = result.sectionIds[ref.sectionIndex];
+            if (!sourceSectionId) {
+                invalidSectionIndexes++;
+                continue;
+            }
+            refs.push({
+                sourceSectionId,
+                branchId: result.branchId,
+                targetDocumentId: target.documentId,
+                displayTitle: ref.displayText || null,
+            });
+        }
+        if (refs.length === 0)
+            continue;
+        try {
+            const { created, skipped, errors } = await client.createReferences(result.documentId, refs);
+            totalCreated += created;
+            totalSkipped += skipped;
+            totalErrors += errors;
+        }
+        catch (error) {
+            console.error(`  Failed to create references for ${result.documentPath}: ${error instanceof Error ? error.message : error}`);
+            totalErrors += refs.length;
+        }
+    }
+    if (unresolvedTargets > 0) {
+        console.log(`  ${unresolvedTargets} reference(s) skipped: target page not in import scope`);
+    }
+    if (invalidSectionIndexes > 0) {
+        console.log(`  ${invalidSectionIndexes} reference(s) skipped: section index out of bounds`);
+    }
+    return { created: totalCreated, skipped: totalSkipped, errors: totalErrors };
+}
 const program = new Command();
 program
     .name('moxn-kb-migrate')
@@ -354,7 +433,17 @@ program
         }
         // Step 3: Run page migration (validate is idempotent, extract uses databaseIdMap)
         const log = await runMigration(source, migrationOptions);
-        // Step 4: Finalize databases — create columns, link entries, assign tags.
+        // Step 4: Resolve cross-references (between page migration and database finalization)
+        if (!opts.dryRun) {
+            const refsWithData = log.results.filter((r) => r.references?.length && r.sectionIds?.length);
+            if (refsWithData.length > 0) {
+                console.log(`\nResolving cross-references from ${refsWithData.length} document(s)...`);
+                const refClient = new MoxnClient(migrationOptions);
+                const refResult = await resolveReferences(refClient, log.results);
+                console.log(`  Created ${refResult.created} reference(s) (${refResult.skipped} skipped, ${refResult.errors} errors)`);
+            }
+        }
+        // Step 5: Finalize databases — create columns, link entries, assign tags.
         // Database records already exist from pre-create; this step adds schema + data.
         if (!opts.dryRun && dbImports.length > 0) {
             console.log(`\nFinalizing ${dbImports.length} database(s)...`);
@@ -370,6 +459,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);
                     }
@@ -534,6 +626,7 @@ async function importNotionDatabase(client, dbImport, log, options, preCreatedDb
                 const tag = await client.createTag({
                     path: tagPath,
                     color: notionColorToHex(option.color),
+                    displayName: option.name,
                 });
                 optionTagMap.set(option.name, tag.id);
                 tagIds.push(tag.id);
@@ -560,6 +653,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 +716,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/notion-database-export.js

@@ -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,84 @@ 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/types.d.ts

@@ -139,6 +139,12 @@ export interface MigrationResult {
     documentId?: string;
     branchId?: string;
     sectionsCount?: number;
+    /** Ordered section IDs from create/update response (for cross-reference resolution) */
+    sectionIds?: string[];
+    /** Cross-references extracted from source (for post-migration resolution) */
+    references?: ExtractedReference[];
+    /** Source page ID (e.g. Notion page ID) for building cross-ref mappings */
+    sourcePageId?: string;
     error?: string;
     duration?: number;
 }

package/package.json

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