@moxn/kb-migrate 0.4.6 → 0.4.8

package/dist/client.d.ts

@@ -2,6 +2,7 @@
  * API client for Moxn KB
  */
 import type { ExtractedDocument, MigrationOptions, MigrationResult, DocumentListItem, DocumentDetail, ExportOptions } from './types.js';
+import type { DateFilter } from './date-filter.js';
 export declare class MoxnClient {
     private apiUrl;
     private apiKey;
@@ -16,7 +17,7 @@ export declare class MoxnClient {
      * List all documents, optionally filtered by path prefix.
      * Handles pagination automatically.
      */
-    listDocuments(pathPrefix?: string): Promise<DocumentListItem[]>;
+    listDocuments(pathPrefix?: string, dateFilter?: DateFilter): Promise<DocumentListItem[]>;
     /**
      * Get full document detail with sections and content.
      */
@@ -79,5 +80,72 @@ export declare class MoxnClient {
      * Assign a tag to a document.
      */
     assignTag(documentId: string, tagId: string, branchId: string): Promise<void>;
+    /**
+     * List all KB databases for the tenant.
+     */
+    listDatabases(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string | null;
+    }>>;
+    /**
+     * Get fully resolved database with columns, options, and document property values.
+     */
+    resolveDatabase(databaseId: string): Promise<{
+        databaseId: string;
+        databaseName: string;
+        columns: Array<{
+            id: string;
+            name: string;
+            type: 'select' | 'multi_select';
+            position: number;
+            newOptionParentPath: string | null;
+            options: Array<{
+                tagId: string;
+                tagName: string;
+                tagPath: string;
+                tagColor: string | null;
+            }>;
+        }>;
+        documents: Array<{
+            documentId: string;
+            documentName: string | null;
+            documentPath: string | null;
+            properties: Record<string, {
+                columnId: string;
+                columnName: string;
+                columnType: 'select' | 'multi_select';
+                values: Array<{
+                    tagId: string;
+                    tagName: string;
+                    tagPath: string;
+                    tagColor: string | null;
+                }>;
+            }>;
+        }>;
+    }>;
+    /**
+     * Get Notion database mapping for a KB database.
+     */
+    getNotionDatabaseMapping(kbDatabaseId: string): Promise<{
+        mapping: {
+            id: string;
+            kbDatabaseId: string;
+            notionDatabaseId: string;
+            notionDatabaseTitle: string | null;
+        } | null;
+    }>;
+    /**
+     * Create or upsert a Notion database mapping.
+     */
+    createNotionDatabaseMapping(input: {
+        kbDatabaseId: string;
+        notionDatabaseId: string;
+        notionDatabaseTitle?: string;
+    }): Promise<{
+        mapping: {
+            id: string;
+        };
+    }>;
     private isConflictError;
 }

package/dist/client.js

@@ -112,7 +112,7 @@ export class MoxnClient {
      * List all documents, optionally filtered by path prefix.
      * Handles pagination automatically.
      */
-    async listDocuments(pathPrefix) {
+    async listDocuments(pathPrefix, dateFilter) {
         const allDocs = [];
         let offset = 0;
         const limit = 100;
@@ -124,6 +124,14 @@ export class MoxnClient {
             if (pathPrefix) {
                 params.set('path', pathPrefix);
             }
+            if (dateFilter?.createdAfter)
+                params.set('createdAfter', dateFilter.createdAfter);
+            if (dateFilter?.createdBefore)
+                params.set('createdBefore', dateFilter.createdBefore);
+            if (dateFilter?.modifiedAfter)
+                params.set('modifiedAfter', dateFilter.modifiedAfter);
+            if (dateFilter?.modifiedBefore)
+                params.set('modifiedBefore', dateFilter.modifiedBefore);
             const response = await fetch(`${this.apiUrl}/api/v1/kb/documents?${params}`, {
                 headers: { 'x-api-key': this.apiKey },
             });
@@ -393,6 +401,62 @@ export class MoxnClient {
             throw new Error(body.error || `Failed to assign tag: ${response.status}`);
         }
     }
+    /**
+     * List all KB databases for the tenant.
+     */
+    async listDatabases() {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/databases`, {
+            headers: { 'x-api-key': this.apiKey },
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to list databases: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.databases;
+    }
+    /**
+     * Get fully resolved database with columns, options, and document property values.
+     */
+    async resolveDatabase(databaseId) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/databases/${databaseId}/resolve`, {
+            headers: { 'x-api-key': this.apiKey },
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to resolve database: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get Notion database mapping for a KB database.
+     */
+    async getNotionDatabaseMapping(kbDatabaseId) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/notion-mappings/databases/by-kb-database/${kbDatabaseId}`, { headers: { 'x-api-key': this.apiKey } });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to get database mapping: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Create or upsert a Notion database mapping.
+     */
+    async createNotionDatabaseMapping(input) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/notion-mappings/databases`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(input),
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to create database mapping: ${response.status}`);
+        }
+        return response.json();
+    }
     isConflictError(error) {
         return (error instanceof Error &&
             'documentId' in error &&

package/dist/date-filter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Date filtering utilities for KB migration
+ */
+export interface DateFilter {
+    createdAfter?: string;
+    createdBefore?: string;
+    modifiedAfter?: string;
+    modifiedBefore?: string;
+}
+/**
+ * Build a DateFilter from CLI option values.
+ * Returns undefined if no date options are set.
+ */
+export declare function buildDateFilter(opts: {
+    createdAfter?: string;
+    createdBefore?: string;
+    modifiedAfter?: string;
+    modifiedBefore?: string;
+}): DateFilter | undefined;
+/**
+ * Check if an item matches the date filter.
+ *
+ * Filter behavior with null modifiedAt:
+ * - modifiedAfter: Excludes null (never modified is not "modified after X")
+ * - modifiedBefore: Excludes null (no modification event to compare)
+ * - createdAfter + modifiedAfter: Union — include if created after OR modified after
+ */
+export declare function matchesDateFilter(filter: DateFilter | undefined, item: {
+    createdAt?: string | Date | null;
+    modifiedAt?: string | Date | null;
+}): boolean;

package/dist/date-filter.js

@@ -0,0 +1,83 @@
+/**
+ * Date filtering utilities for KB migration
+ */
+/**
+ * Build a DateFilter from CLI option values.
+ * Returns undefined if no date options are set.
+ */
+export function buildDateFilter(opts) {
+    const filter = {};
+    if (opts.createdAfter)
+        filter.createdAfter = opts.createdAfter;
+    if (opts.createdBefore)
+        filter.createdBefore = opts.createdBefore;
+    if (opts.modifiedAfter)
+        filter.modifiedAfter = opts.modifiedAfter;
+    if (opts.modifiedBefore)
+        filter.modifiedBefore = opts.modifiedBefore;
+    return Object.keys(filter).length > 0 ? filter : undefined;
+}
+/**
+ * Check if an item matches the date filter.
+ *
+ * Filter behavior with null modifiedAt:
+ * - modifiedAfter: Excludes null (never modified is not "modified after X")
+ * - modifiedBefore: Excludes null (no modification event to compare)
+ * - createdAfter + modifiedAfter: Union — include if created after OR modified after
+ */
+export function matchesDateFilter(filter, item) {
+    if (!filter)
+        return true;
+    const createdAt = item.createdAt ? new Date(item.createdAt).getTime() : null;
+    const modifiedAt = item.modifiedAt ? new Date(item.modifiedAt).getTime() : null;
+    // When both created and modified "after" are set, use union logic
+    const hasCreatedAfter = !!filter.createdAfter;
+    const hasModifiedAfter = !!filter.modifiedAfter;
+    const useUnionForAfter = hasCreatedAfter && hasModifiedAfter;
+    let createdAfterMatch = true;
+    let modifiedAfterMatch = true;
+    if (filter.createdAfter && createdAt !== null) {
+        createdAfterMatch = createdAt >= new Date(filter.createdAfter).getTime();
+    }
+    else if (filter.createdAfter && createdAt === null) {
+        createdAfterMatch = false;
+    }
+    if (filter.modifiedAfter) {
+        if (modifiedAt !== null) {
+            modifiedAfterMatch = modifiedAt >= new Date(filter.modifiedAfter).getTime();
+        }
+        else {
+            modifiedAfterMatch = false;
+        }
+    }
+    // Union: pass if either matches
+    if (useUnionForAfter) {
+        if (!createdAfterMatch && !modifiedAfterMatch)
+            return false;
+    }
+    else {
+        // Individual: each must pass
+        if (hasCreatedAfter && !createdAfterMatch)
+            return false;
+        if (hasModifiedAfter && !modifiedAfterMatch)
+            return false;
+    }
+    // "Before" filters are always AND (restrictive)
+    if (filter.createdBefore && createdAt !== null) {
+        if (createdAt > new Date(filter.createdBefore).getTime())
+            return false;
+    }
+    else if (filter.createdBefore && createdAt === null) {
+        return false;
+    }
+    if (filter.modifiedBefore) {
+        if (modifiedAt !== null) {
+            if (modifiedAt > new Date(filter.modifiedBefore).getTime())
+                return false;
+        }
+        else {
+            return false; // null modifiedAt excluded from modifiedBefore filter
+        }
+    }
+    return true;
+}

package/dist/export-notion.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Export runner for Moxn KB -> Notion
+ *
+ * Fetches documents from the KB API and exports them to Notion pages
+ * using the NotionExportTarget with a two-pass algorithm:
+ *
+ * Pass 1: Create/update all Notion pages (content without cross-references)
+ * Pass 2: Resolve KB path references to Notion page IDs and append link blocks
+ */
+import type { ExportTargetLog } from './targets/base.js';
+import type { DateFilter } from './date-filter.js';
+export interface ExportNotionOptions {
+    apiUrl: string;
+    apiKey: string;
+    notionToken: string;
+    parentPageId: string;
+    basePath: string;
+    conflictStrategy: 'skip' | 'update';
+    dryRun: boolean;
+    dateFilter?: DateFilter;
+}
+export declare function runNotionExport(options: ExportNotionOptions): Promise<ExportTargetLog>;

package/dist/export-notion.js

@@ -0,0 +1,242 @@
+/**
+ * Export runner for Moxn KB -> Notion
+ *
+ * Fetches documents from the KB API and exports them to Notion pages
+ * using the NotionExportTarget with a two-pass algorithm:
+ *
+ * Pass 1: Create/update all Notion pages (content without cross-references)
+ * Pass 2: Resolve KB path references to Notion page IDs and append link blocks
+ */
+import { Client } from '@notionhq/client';
+import { MoxnClient } from './client.js';
+import { matchesDateFilter } from './date-filter.js';
+import { NotionExportTarget } from './targets/notion.js';
+import { exportDatabase } from './targets/notion-database-export.js';
+export async function runNotionExport(options) {
+    const startTime = Date.now();
+    // Create Moxn client for reading docs
+    const client = new MoxnClient({
+        apiUrl: options.apiUrl,
+        apiKey: options.apiKey,
+        basePath: options.basePath,
+        imageDir: 'images',
+        pdfDir: 'pdfs',
+        csvDir: 'csvs',
+        dryRun: options.dryRun,
+    });
+    // Create Notion export target
+    const target = new NotionExportTarget({
+        notionToken: options.notionToken,
+        parentPageId: options.parentPageId,
+        conflictStrategy: options.conflictStrategy,
+        apiUrl: options.apiUrl,
+        apiKey: options.apiKey,
+    });
+    // Validate target
+    await target.validate();
+    // List documents
+    console.log('Fetching document list...');
+    const allDocuments = await client.listDocuments(options.basePath || undefined, options.dateFilter);
+    // Apply client-side date filtering
+    let documents = allDocuments;
+    if (options.dateFilter) {
+        documents = allDocuments.filter((doc) => matchesDateFilter(options.dateFilter, {
+            createdAt: doc.createdAt,
+            modifiedAt: doc.updatedAt,
+        }));
+        const skipped = allDocuments.length - documents.length;
+        if (skipped > 0) {
+            console.log(`Filtered ${skipped} documents by date criteria`);
+        }
+    }
+    console.log(`Found ${documents.length} documents to export`);
+    if (documents.length === 0) {
+        return buildEmptyLog(options, startTime);
+    }
+    // ============================================
+    // Pre-fetch all documents for two-pass export
+    // ============================================
+    console.log('Fetching document details...');
+    const docDetails = [];
+    for (let i = 0; i < documents.length; i++) {
+        const docItem = documents[i];
+        try {
+            const doc = await client.getDocument(docItem.id);
+            docDetails.push({ listItem: docItem, detail: doc });
+            // Register the document path -> ID mapping for reference resolution
+            target.registerDocument(doc);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`  Warning: Failed to fetch ${docItem.path}: ${message}`);
+        }
+    }
+    // ============================================
+    // Pass 1: Create/update Notion pages
+    // ============================================
+    console.log(`\nPass 1: Exporting ${docDetails.length} documents to Notion...`);
+    const results = [];
+    for (let i = 0; i < docDetails.length; i++) {
+        const { listItem: docItem, detail: doc } = docDetails[i];
+        const progress = `(${i + 1}/${docDetails.length})`;
+        console.log(`Processing: ${docItem.path} ${progress}`);
+        try {
+            const result = await target.exportDocument(doc, docItem, options.dryRun);
+            results.push(result);
+            const statusIcon = {
+                created: '\u2713',
+                updated: '\u21bb',
+                skipped: '-',
+                failed: '\u2717',
+            }[result.status];
+            const extIdStr = result.externalId ? ` [${result.externalId}]` : '';
+            console.log(`  ${statusIcon} ${result.status}: ${result.documentPath}${extIdStr}`);
+            if (result.error) {
+                console.log(`    Error: ${result.error}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`  \u2717 failed: ${docItem.path}`);
+            console.log(`    Error: ${message}`);
+            results.push({
+                documentId: docItem.id,
+                documentPath: docItem.path,
+                status: 'failed',
+                error: message,
+                duration: 0,
+            });
+        }
+    }
+    // ============================================
+    // Pass 1.5: Export databases
+    // ============================================
+    if (!options.dryRun) {
+        // Collect unique database IDs from exported documents
+        const databaseIdsToExport = new Set();
+        for (const { detail: doc } of docDetails) {
+            for (const section of doc.sections) {
+                for (const block of section.content) {
+                    if (block.blockType === 'database_embed' && block.databaseId) {
+                        databaseIdsToExport.add(block.databaseId);
+                    }
+                }
+            }
+        }
+        if (databaseIdsToExport.size > 0) {
+            console.log(`\nPass 1.5: Exporting ${databaseIdsToExport.size} databases to Notion...`);
+            const dbCtx = {
+                notionClient: new Client({ auth: options.notionToken }),
+                moxnClient: client,
+                conflictStrategy: options.conflictStrategy,
+                dryRun: options.dryRun,
+            };
+            let dbCreated = 0, dbUpdated = 0, dbSkipped = 0, dbFailed = 0;
+            for (const dbId of databaseIdsToExport) {
+                try {
+                    // 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];
+                    console.log(`  ${icon} ${result.status}: ${result.kbDatabaseName} (${result.entriesCreated} entries)`);
+                    if (result.error)
+                        console.log(`    Error: ${result.error}`);
+                    if (result.status === 'created')
+                        dbCreated++;
+                    else if (result.status === 'updated')
+                        dbUpdated++;
+                    else if (result.status === 'skipped')
+                        dbSkipped++;
+                    else if (result.status === 'failed')
+                        dbFailed++;
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    console.log(`  \u2717 failed: database ${dbId}`);
+                    console.log(`    Error: ${msg}`);
+                    dbFailed++;
+                }
+            }
+            console.log(`\nDatabases: ${dbCreated} created, ${dbUpdated} updated, ${dbSkipped} skipped, ${dbFailed} failed`);
+        }
+    }
+    // ============================================
+    // Pass 2: Resolve cross-references
+    // ============================================
+    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);
+        if (successfulExports.length > 0) {
+            console.log(`\nPass 2: Resolving cross-references for ${successfulExports.length} documents...`);
+            let totalResolved = 0;
+            let totalUnresolved = 0;
+            for (const result of successfulExports) {
+                const docDetail = docDetails.find((d) => d.detail.id === result.documentId);
+                if (!docDetail || !result.externalId)
+                    continue;
+                try {
+                    const { resolved, unresolved } = await target.resolveAndAppendReferences(docDetail.detail, result.externalId);
+                    if (resolved > 0 || unresolved > 0) {
+                        console.log(`  ${docDetail.detail.path}: ${resolved} resolved, ${unresolved} unresolved`);
+                    }
+                    totalResolved += resolved;
+                    totalUnresolved += unresolved;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.log(`  Warning: Reference resolution failed for ${docDetail.detail.path}: ${message}`);
+                }
+            }
+            if (totalResolved > 0 || totalUnresolved > 0) {
+                console.log(`\nReferences: ${totalResolved} resolved, ${totalUnresolved} unresolved`);
+            }
+        }
+    }
+    await target.cleanup();
+    return {
+        timestamp: new Date().toISOString(),
+        sourceApi: options.apiUrl,
+        target: {
+            type: target.targetType,
+            location: target.targetLocation,
+        },
+        basePath: options.basePath || '/',
+        options: {
+            dryRun: options.dryRun,
+            conflictStrategy: options.conflictStrategy,
+        },
+        results,
+        summary: {
+            total: results.length,
+            created: results.filter((r) => r.status === 'created').length,
+            updated: results.filter((r) => r.status === 'updated').length,
+            skipped: results.filter((r) => r.status === 'skipped').length,
+            failed: results.filter((r) => r.status === 'failed').length,
+            duration: Date.now() - startTime,
+        },
+    };
+}
+function buildEmptyLog(options, startTime) {
+    return {
+        timestamp: new Date().toISOString(),
+        sourceApi: options.apiUrl,
+        target: {
+            type: 'notion',
+            location: `Notion (parent: ${options.parentPageId})`,
+        },
+        basePath: options.basePath || '/',
+        options: {
+            dryRun: options.dryRun,
+            conflictStrategy: options.conflictStrategy,
+        },
+        results: [],
+        summary: {
+            total: 0,
+            created: 0,
+            updated: 0,
+            skipped: 0,
+            failed: 0,
+            duration: Date.now() - startTime,
+        },
+    };
+}

package/dist/export.js

@@ -7,6 +7,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { MoxnClient } from './client.js';
+import { matchesDateFilter } from './date-filter.js';
 // ──────────────────────────────────────────────
 // Utility functions
 // ──────────────────────────────────────────────
@@ -141,7 +142,19 @@ export async function runExport(outputDir, options) {
     const client = new MoxnClient(options);
     // List documents
     console.error('Fetching document list...');
-    const documents = await client.listDocuments(options.basePath || undefined);
+    const allDocuments = await client.listDocuments(options.basePath || undefined, options.dateFilter);
+    // Apply client-side date filtering as well
+    let documents = allDocuments;
+    if (options.dateFilter) {
+        documents = allDocuments.filter((doc) => matchesDateFilter(options.dateFilter, {
+            createdAt: doc.createdAt,
+            modifiedAt: doc.updatedAt,
+        }));
+        const skipped = allDocuments.length - documents.length;
+        if (skipped > 0) {
+            console.error(`Filtered ${skipped} documents by date criteria`);
+        }
+    }
     console.error(`Found ${documents.length} documents`);
     if (documents.length === 0) {
         return {