@moxn/kb-migrate 0.2.1 → 0.3.0

package/dist/client.d.ts

@@ -28,6 +28,13 @@ export declare class MoxnClient {
     private buildPath;
     private processSections;
     private processContentBlocks;
+    /**
+     * Upload a file to Moxn storage and return the storage key.
+     */
+    uploadFile(data: Buffer, mimeType: string, filename?: string): Promise<{
+        key: string;
+    }>;
+    private getUploadUrl;
     private createDocument;
     private updateDocument;
     private isConflictError;

package/dist/client.js

@@ -179,20 +179,69 @@ export class MoxnClient {
     }
     async processContentBlocks(blocks) {
         return Promise.all(blocks.map(async (block) => {
+            // Handle image files - upload to storage
             if (block.blockType === 'image' && block.type === 'file' && block.path) {
-                // Convert local file to base64
                 const data = await fs.readFile(block.path);
+                const filename = block.path.split('/').pop();
+                const { key } = await this.uploadFile(data, block.mediaType, filename);
                 return {
                     blockType: block.blockType,
-                    type: 'base64',
-                    base64: data.toString('base64'),
+                    type: 'storage',
+                    key,
                     mediaType: block.mediaType,
                     alt: block.alt,
                 };
             }
+            // Handle CSV files - upload to storage
+            if (block.blockType === 'csv' && block.type === 'file' && block.path) {
+                const data = await fs.readFile(block.path);
+                const { key } = await this.uploadFile(data, 'text/csv', block.filename);
+                return {
+                    blockType: block.blockType,
+                    type: 'storage',
+                    key,
+                    mediaType: 'text/csv',
+                    filename: block.filename,
+                    headers: block.headers,
+                    rowCount: block.rowCount,
+                };
+            }
             return block;
         }));
     }
+    /**
+     * Upload a file to Moxn storage and return the storage key.
+     */
+    async uploadFile(data, mimeType, filename) {
+        // 1. Get presigned upload URL
+        const { key, uploadUrl } = await this.getUploadUrl(mimeType, filename);
+        // 2. PUT file to presigned URL
+        const response = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: { 'Content-Type': mimeType },
+            body: new Uint8Array(data),
+        });
+        if (!response.ok) {
+            throw new Error(`File upload failed: ${response.status}`);
+        }
+        return { key };
+    }
+    async getUploadUrl(type, filename) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/upload`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify({ type, filename }),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Upload URL request failed: ${response.status} ${body}`);
+        }
+        const data = await response.json();
+        return { key: data.key, uploadUrl: data.uploadUrl };
+    }
     async createDocument(request) {
         const response = await fetch(`${this.apiUrl}/api/v1/kb/documents`, {
             method: 'POST',

package/dist/export.js

@@ -10,15 +10,9 @@ import { MoxnClient } from './client.js';
 // ──────────────────────────────────────────────
 // Utility functions
 // ──────────────────────────────────────────────
-/** Strip <moxn:comment> tags from text, preserving the inner text. Handles nested/double-wrapped tags. */
+/** Strip <moxn:comment> tags from text, preserving the inner text. */
 function stripCommentTags(text) {
-    const pattern = /<moxn:comment[^>]*>([\s\S]*?)<\/moxn:comment>/g;
-    let result = text;
-    // Loop until no more comment tags remain (handles nested/double-wrapped tags from TipTap CRDT)
-    while (pattern.test(result)) {
-        result = result.replace(pattern, '$1');
-    }
-    return result;
+    return text.replace(/<moxn:comment[^>]*>([\s\S]*?)<\/moxn:comment>/g, '$1');
 }
 /** Derive a local filename from a storage key or URL. */
 function deriveFilename(storageKey, url, fallbackExt) {

package/dist/sources/local.d.ts

@@ -27,10 +27,14 @@ export declare class LocalSource extends MigrationSource<LocalSourceConfig> {
     private parseMarkdownSections;
     private nodesToContentBlocks;
     /**
-     * Extract image nodes from paragraph children, returning image blocks
-     * and whether non-image text content exists.
+     * Extract image nodes and CSV links from paragraph children, returning media blocks
+     * and whether non-media text content exists.
      */
     private extractImagesFromParagraph;
+    /**
+     * Convert a markdown link to a CSV block if it points to a local CSV file.
+     */
+    private linkToCSVBlock;
     private imageToBlock;
     private guessImageType;
     private extensionToMediaType;

package/dist/sources/local.js

@@ -4,6 +4,7 @@
  * Extracts documents from local markdown and text files.
  */
 import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
 import * as path from 'path';
 import { glob } from 'glob';
 import { unified } from 'unified';
@@ -85,7 +86,6 @@ export class LocalSource extends MigrationSource {
     }
     async extractDocument(relativePath) {
         const fullPath = path.join(this.config.directory, relativePath);
-        const content = await fs.readFile(fullPath, 'utf-8');
         // Parse relative path to create document path
         const parsed = path.parse(relativePath);
         const dirParts = parsed.dir ? parsed.dir.split(path.sep) : [];
@@ -100,6 +100,7 @@ export class LocalSource extends MigrationSource {
             .split(/[-_]/)
             .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
             .join(' ');
+        const content = await fs.readFile(fullPath, 'utf-8');
         // Parse into sections
         const sections = this.parseMarkdownSections(content, path.dirname(fullPath));
         if (sections.length === 0) {
@@ -218,8 +219,8 @@ export class LocalSource extends MigrationSource {
         return blocks;
     }
     /**
-     * Extract image nodes from paragraph children, returning image blocks
-     * and whether non-image text content exists.
+     * Extract image nodes and CSV links from paragraph children, returning media blocks
+     * and whether non-media text content exists.
      */
     extractImagesFromParagraph(children, baseDir) {
         const images = [];
@@ -231,6 +232,20 @@ export class LocalSource extends MigrationSource {
                     images.push(imageBlock);
                 }
             }
+            else if (child.type === 'link') {
+                // Check if this is a link to a CSV file
+                const csvBlock = this.linkToCSVBlock(child, baseDir);
+                if (csvBlock) {
+                    images.push(csvBlock);
+                }
+                else {
+                    // Regular link, treat as text
+                    const text = this.nodeToMarkdown(child).trim();
+                    if (text) {
+                        hasText = true;
+                    }
+                }
+            }
             else {
                 // Check if the child has any meaningful text
                 const text = this.nodeToMarkdown(child).trim();
@@ -241,6 +256,36 @@ export class LocalSource extends MigrationSource {
         }
         return { images, hasText };
     }
+    /**
+     * Convert a markdown link to a CSV block if it points to a local CSV file.
+     */
+    linkToCSVBlock(node, baseDir) {
+        const href = node.url;
+        // Only handle local CSV files
+        if (href.startsWith('http://') || href.startsWith('https://')) {
+            return null;
+        }
+        if (!href.toLowerCase().endsWith('.csv')) {
+            return null;
+        }
+        const csvPath = path.isAbsolute(href) ? href : path.join(baseDir, href);
+        if (!fsSync.existsSync(csvPath)) {
+            return null;
+        }
+        // Read CSV for metadata
+        const content = fsSync.readFileSync(csvPath, 'utf-8');
+        const lines = content.split('\n').filter((l) => l.trim());
+        const headers = lines[0]?.split(',').map((h) => h.trim()) || [];
+        return {
+            blockType: 'csv',
+            type: 'file',
+            path: csvPath,
+            mediaType: 'text/csv',
+            filename: path.basename(csvPath),
+            headers,
+            rowCount: Math.max(0, lines.length - 1),
+        };
+    }
     imageToBlock(node, baseDir) {
         const url = node.url;
         // Handle external URLs

package/dist/types.d.ts

@@ -5,15 +5,19 @@
  * A content block in a section
  */
 export interface ContentBlock {
-    blockType: 'text' | 'image' | 'document';
+    blockType: 'text' | 'image' | 'document' | 'csv';
     text?: string;
-    type?: 'base64' | 'url' | 'file';
+    type?: 'base64' | 'url' | 'file' | 'storage';
     mediaType?: string;
     path?: string;
     url?: string;
     base64?: string;
+    key?: string;
     alt?: string;
     filename?: string;
+    /** CSV-specific metadata */
+    headers?: string[];
+    rowCount?: number;
 }
 /**
  * A section to be created in a document

package/package.json

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