@moxn/kb-migrate 0.4.20 → 0.4.21

package/dist/client.d.ts

@@ -72,6 +72,7 @@ export declare class MoxnClient {
         path: string;
         description?: string;
         color?: string;
+        displayName?: string;
     }): Promise<{
         id: string;
         path: string;
@@ -81,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.
      */

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.
      */

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)...`);
@@ -537,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);

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

@@ -292,7 +292,10 @@ async function createDatabaseEntries(ctx, dataSourceId, resolved) {
                 }
                 else {
                     // Scalar columns (number, date, text, url, email)
-                    if (propValue.textValue == null && propValue.numberValue == null && propValue.dateValue == null && propValue.booleanValue == null)
+                    if (propValue.textValue == null &&
+                        propValue.numberValue == null &&
+                        propValue.dateValue == null &&
+                        propValue.booleanValue == null)
                         continue;
                     switch (propValue.columnType) {
                         case 'number':

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.20",
+  "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",