@moxn/kb-migrate 0.4.3 → 0.4.7

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,17 @@ export declare class MoxnClient {
      * Assign a tag to a document.
      */
     assignTag(documentId: string, tagId: string, branchId: string): Promise<void>;
+    /**
+     * 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,24 @@ export class MoxnClient {
             throw new Error(body.error || `Failed to assign tag: ${response.status}`);
         }
     }
+    /**
+     * 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,188 @@
+/**
+ * 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 { MoxnClient } from './client.js';
+import { matchesDateFilter } from './date-filter.js';
+import { NotionExportTarget } from './targets/notion.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 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 {