@moxn/kb-migrate 0.1.0

package/bin/moxn-kb-migrate

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/client.d.ts

@@ -0,0 +1,21 @@
+/**
+ * API client for Moxn KB
+ */
+import type { ExtractedDocument, MigrationOptions, MigrationResult } from './types.js';
+export declare class MoxnClient {
+    private apiUrl;
+    private apiKey;
+    private defaultPermission?;
+    private aiAccess?;
+    constructor(options: MigrationOptions);
+    /**
+     * Migrate a single document
+     */
+    migrateDocument(doc: ExtractedDocument, basePath: string, onConflict: 'skip' | 'update', dryRun: boolean): Promise<MigrationResult>;
+    private buildPath;
+    private processSections;
+    private processContentBlocks;
+    private createDocument;
+    private updateDocument;
+    private isConflictError;
+}

package/dist/client.js

@@ -0,0 +1,174 @@
+/**
+ * API client for Moxn KB
+ */
+import * as fs from 'fs/promises';
+export class MoxnClient {
+    apiUrl;
+    apiKey;
+    defaultPermission;
+    aiAccess;
+    constructor(options) {
+        this.apiUrl = options.apiUrl.replace(/\/$/, '');
+        this.apiKey = options.apiKey;
+        this.defaultPermission = options.defaultPermission;
+        this.aiAccess = options.aiAccess;
+    }
+    /**
+     * Migrate a single document
+     */
+    async migrateDocument(doc, basePath, onConflict, dryRun) {
+        const startTime = Date.now();
+        const documentPath = this.buildPath(basePath, doc.relativePath);
+        if (dryRun) {
+            return {
+                sourcePath: doc.sourcePath,
+                documentPath,
+                status: 'skipped',
+                sectionsCount: doc.sections.length,
+                duration: Date.now() - startTime,
+            };
+        }
+        try {
+            // Process content blocks (convert file paths to base64)
+            const processedSections = await this.processSections(doc.sections);
+            // Try to create the document
+            const createResult = await this.createDocument({
+                path: documentPath,
+                name: doc.name,
+                description: doc.description,
+                defaultPermission: this.defaultPermission,
+                aiAccess: this.aiAccess,
+                sections: processedSections,
+            });
+            return {
+                sourcePath: doc.sourcePath,
+                documentPath,
+                status: 'created',
+                documentId: createResult.id,
+                branchId: createResult.branchId,
+                sectionsCount: createResult.sections.length,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            // Check for conflict (409)
+            if (this.isConflictError(error)) {
+                if (onConflict === 'skip') {
+                    return {
+                        sourcePath: doc.sourcePath,
+                        documentPath,
+                        status: 'skipped',
+                        documentId: error.documentId,
+                        branchId: error.branchId,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                // Update existing document
+                try {
+                    const processedSections = await this.processSections(doc.sections);
+                    const updateResult = await this.updateDocument(error.documentId, {
+                        name: doc.name,
+                        description: doc.description,
+                        sections: processedSections,
+                    });
+                    return {
+                        sourcePath: doc.sourcePath,
+                        documentPath,
+                        status: 'updated',
+                        documentId: updateResult.id,
+                        branchId: updateResult.branchId,
+                        sectionsCount: updateResult.sections.length,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                catch (updateError) {
+                    return {
+                        sourcePath: doc.sourcePath,
+                        documentPath,
+                        status: 'failed',
+                        documentId: error.documentId,
+                        error: updateError instanceof Error ? updateError.message : 'Update failed',
+                        duration: Date.now() - startTime,
+                    };
+                }
+            }
+            return {
+                sourcePath: doc.sourcePath,
+                documentPath,
+                status: 'failed',
+                error: error instanceof Error ? error.message : 'Unknown error',
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    buildPath(basePath, relativePath) {
+        const base = basePath.replace(/^\/+|\/+$/g, '');
+        const rel = relativePath.replace(/^\/+|\/+$/g, '');
+        return '/' + (base ? `${base}/${rel}` : rel);
+    }
+    async processSections(sections) {
+        return Promise.all(sections.map(async (section) => ({
+            name: section.name,
+            content: await this.processContentBlocks(section.content),
+        })));
+    }
+    async processContentBlocks(blocks) {
+        return Promise.all(blocks.map(async (block) => {
+            if (block.blockType === 'image' && block.type === 'file' && block.path) {
+                // Convert local file to base64
+                const data = await fs.readFile(block.path);
+                return {
+                    blockType: block.blockType,
+                    type: 'base64',
+                    base64: data.toString('base64'),
+                    mediaType: block.mediaType,
+                    alt: block.alt,
+                };
+            }
+            return block;
+        }));
+    }
+    async createDocument(request) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/documents`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            if (response.status === 409 && body.documentId) {
+                const error = new Error(body.error || 'Document already exists');
+                error.documentId = body.documentId;
+                error.branchId = body.branchId;
+                throw error;
+            }
+            throw new Error(body.error || `API error: ${response.status}`);
+        }
+        return response.json();
+    }
+    async updateDocument(documentId, request) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/documents/${documentId}`, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `API error: ${response.status}`);
+        }
+        return response.json();
+    }
+    isConflictError(error) {
+        return (error instanceof Error &&
+            'documentId' in error &&
+            'branchId' in error &&
+            typeof error.documentId === 'string' &&
+            typeof error.branchId === 'string');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Moxn KB Migration Tool
+ *
+ * Import documents into Moxn Knowledge Base from various sources.
+ *
+ * Usage:
+ *   moxn-kb-migrate local ./docs --api-key=xxx --base-path=/imported
+ *   moxn-kb-migrate local ./docs --dry-run
+ *
+ * Environment variables:
+ *   MOXN_API_KEY    - API key for authentication
+ *   MOXN_API_URL    - API base URL (default: https://moxn.dev)
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Moxn KB Migration Tool
+ *
+ * Import documents into Moxn Knowledge Base from various sources.
+ *
+ * Usage:
+ *   moxn-kb-migrate local ./docs --api-key=xxx --base-path=/imported
+ *   moxn-kb-migrate local ./docs --dry-run
+ *
+ * Environment variables:
+ *   MOXN_API_KEY    - API key for authentication
+ *   MOXN_API_URL    - API base URL (default: https://moxn.dev)
+ */
+import { Command } from 'commander';
+import { LocalSource } from './sources/local.js';
+import { MoxnClient } from './client.js';
+const DEFAULT_API_URL = 'https://moxn.dev';
+const DEFAULT_EXTENSIONS = ['.md', '.txt'];
+async function runMigration(source, options) {
+    const startTime = Date.now();
+    const results = [];
+    // Validate source
+    await source.validate();
+    // Get document count for progress
+    const totalCount = await source.getDocumentCount();
+    if (totalCount !== undefined) {
+        console.log(`Found ${totalCount} documents to migrate`);
+    }
+    // Create client
+    const client = new MoxnClient(options);
+    // Process documents
+    let processed = 0;
+    for await (const doc of source.extract()) {
+        processed++;
+        const progress = totalCount ? ` (${processed}/${totalCount})` : '';
+        console.log(`Processing: ${doc.sourcePath}${progress}`);
+        const result = await client.migrateDocument(doc, options.basePath, options.onConflict, options.dryRun);
+        results.push(result);
+        // Log result
+        const statusIcon = {
+            created: '\u2713',
+            updated: '\u21bb',
+            skipped: '-',
+            failed: '\u2717',
+        }[result.status];
+        console.log(`  ${statusIcon} ${result.status}: ${result.documentPath}`);
+        if (result.error) {
+            console.log(`    Error: ${result.error}`);
+        }
+    }
+    // Build summary
+    const 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,
+    };
+    const log = {
+        timestamp: new Date().toISOString(),
+        source: {
+            type: source.sourceType,
+            location: source.sourceLocation,
+        },
+        targetApi: options.apiUrl,
+        basePath: options.basePath,
+        options: {
+            dryRun: options.dryRun,
+            onConflict: options.onConflict,
+        },
+        results,
+        summary,
+    };
+    return log;
+}
+function printSummary(log) {
+    console.log('\n--- Migration Summary ---');
+    console.log(`Source: ${log.source.type} (${log.source.location})`);
+    console.log(`Target: ${log.targetApi}`);
+    console.log(`Base path: ${log.basePath}`);
+    console.log(`Duration: ${(log.summary.duration / 1000).toFixed(1)}s`);
+    console.log('');
+    console.log(`Total:   ${log.summary.total}`);
+    console.log(`Created: ${log.summary.created}`);
+    console.log(`Updated: ${log.summary.updated}`);
+    console.log(`Skipped: ${log.summary.skipped}`);
+    console.log(`Failed:  ${log.summary.failed}`);
+    if (log.options.dryRun) {
+        console.log('\n(Dry run - no changes made)');
+    }
+}
+const program = new Command();
+program
+    .name('moxn-kb-migrate')
+    .description('Import documents into Moxn Knowledge Base')
+    .version('0.1.0');
+program
+    .command('local <directory>')
+    .description('Migrate documents from local filesystem')
+    .option('--api-key <key>', 'API key (or set MOXN_API_KEY env var)')
+    .option('--api-url <url>', 'API base URL', DEFAULT_API_URL)
+    .option('--base-path <path>', 'Base path for imported documents', '/')
+    .option('--extensions <exts>', 'Comma-separated file extensions', DEFAULT_EXTENSIONS.join(','))
+    .option('--on-conflict <action>', 'Action on conflict: skip or update', 'skip')
+    .option('--default-permission <perm>', 'Default permission: edit, read, or none')
+    .option('--ai-access <perm>', 'AI access permission: edit, read, or none')
+    .option('--dry-run', 'Preview without making changes', false)
+    .option('--json', 'Output results as JSON', false)
+    .action(async (directory, opts) => {
+    const apiKey = opts.apiKey || process.env.MOXN_API_KEY;
+    if (!apiKey) {
+        console.error('Error: API key required. Use --api-key or set MOXN_API_KEY env var.');
+        process.exit(1);
+    }
+    const extensions = opts.extensions.split(',').map((e) => e.trim());
+    const onConflict = opts.onConflict;
+    if (!['skip', 'update'].includes(onConflict)) {
+        console.error('Error: --on-conflict must be "skip" or "update"');
+        process.exit(1);
+    }
+    const source = new LocalSource({
+        directory,
+        extensions,
+    });
+    const migrationOptions = {
+        apiUrl: opts.apiUrl,
+        apiKey,
+        basePath: opts.basePath,
+        onConflict,
+        dryRun: opts.dryRun,
+        defaultPermission: opts.defaultPermission,
+        aiAccess: opts.aiAccess,
+    };
+    try {
+        const log = await runMigration(source, migrationOptions);
+        if (opts.json) {
+            console.log(JSON.stringify(log, null, 2));
+        }
+        else {
+            printSummary(log);
+        }
+        // Exit with error code if any failures
+        if (log.summary.failed > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Migration failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Future: Add notion and google-docs commands here
+// program
+//   .command('notion')
+//   .description('Migrate documents from Notion')
+//   .option('--token <token>', 'Notion integration token')
+//   .action(...)
+program.parse();

package/dist/sources/base.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Base interface for migration sources
+ *
+ * Each source (local files, Notion, Google Docs) implements this interface
+ * to provide a consistent way to extract documents for migration.
+ */
+import type { ExtractedDocument } from '../types.js';
+/**
+ * Configuration options specific to a source type
+ */
+export interface SourceConfig {
+    [key: string]: unknown;
+}
+/**
+ * Abstract base class for migration sources
+ */
+export declare abstract class MigrationSource<TConfig extends SourceConfig = SourceConfig> {
+    protected config: TConfig;
+    constructor(config: TConfig);
+    /**
+     * Human-readable name of the source type
+     */
+    abstract get sourceType(): string;
+    /**
+     * Human-readable location identifier for logging
+     */
+    abstract get sourceLocation(): string;
+    /**
+     * Validate the source configuration and connectivity
+     * @throws Error if configuration is invalid or source is not accessible
+     */
+    abstract validate(): Promise<void>;
+    /**
+     * Extract all documents from the source
+     * @yields ExtractedDocument for each document found
+     */
+    abstract extract(): AsyncGenerator<ExtractedDocument, void, unknown>;
+    /**
+     * Get the total count of documents (if known)
+     * Returns undefined if count cannot be determined without full extraction
+     */
+    abstract getDocumentCount(): Promise<number | undefined>;
+}

package/dist/sources/base.js

@@ -0,0 +1,15 @@
+/**
+ * Base interface for migration sources
+ *
+ * Each source (local files, Notion, Google Docs) implements this interface
+ * to provide a consistent way to extract documents for migration.
+ */
+/**
+ * Abstract base class for migration sources
+ */
+export class MigrationSource {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}

package/dist/sources/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Source registry and factory
+ */
+export { MigrationSource, type SourceConfig } from './base.js';
+export { LocalSource, type LocalSourceConfig } from './local.js';

package/dist/sources/index.js

@@ -0,0 +1,8 @@
+/**
+ * Source registry and factory
+ */
+export { MigrationSource } from './base.js';
+export { LocalSource } from './local.js';
+// Future sources:
+// export { NotionSource, type NotionSourceConfig } from './notion.js';
+// export { GoogleDocsSource, type GoogleDocsSourceConfig } from './google-docs.js';

package/dist/sources/local.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Local filesystem source for migration
+ *
+ * Extracts documents from local markdown and text files.
+ */
+import { MigrationSource, type SourceConfig } from './base.js';
+import type { ExtractedDocument } from '../types.js';
+export interface LocalSourceConfig extends SourceConfig {
+    /** Directory path to scan for documents */
+    directory: string;
+    /** File extensions to include (default: ['.md', '.txt']) */
+    extensions: string[];
+}
+/**
+ * Local filesystem migration source
+ */
+export declare class LocalSource extends MigrationSource<LocalSourceConfig> {
+    private files;
+    get sourceType(): string;
+    get sourceLocation(): string;
+    validate(): Promise<void>;
+    getDocumentCount(): Promise<number | undefined>;
+    extract(): AsyncGenerator<ExtractedDocument, void, unknown>;
+    private discoverFiles;
+    private extractDocument;
+    private parseMarkdownSections;
+    private nodesToContentBlocks;
+    private imageToBlock;
+    private guessImageType;
+    private extensionToMediaType;
+    private extractText;
+    private nodeToMarkdown;
+    private tableToMarkdown;
+}

package/dist/sources/local.js

@@ -0,0 +1,301 @@
+/**
+ * Local filesystem source for migration
+ *
+ * Extracts documents from local markdown and text files.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import { MigrationSource } from './base.js';
+/**
+ * Local filesystem migration source
+ */
+export class LocalSource extends MigrationSource {
+    files = null;
+    get sourceType() {
+        return 'local';
+    }
+    get sourceLocation() {
+        return this.config.directory;
+    }
+    async validate() {
+        const stats = await fs.stat(this.config.directory);
+        if (!stats.isDirectory()) {
+            throw new Error(`Not a directory: ${this.config.directory}`);
+        }
+    }
+    async getDocumentCount() {
+        if (!this.files) {
+            await this.discoverFiles();
+        }
+        return this.files.length;
+    }
+    async *extract() {
+        if (!this.files) {
+            await this.discoverFiles();
+        }
+        for (const file of this.files) {
+            const doc = await this.extractDocument(file);
+            if (doc) {
+                yield doc;
+            }
+        }
+    }
+    async discoverFiles() {
+        const patterns = this.config.extensions.map((ext) => `**/*${ext.startsWith('.') ? ext : '.' + ext}`);
+        const allFiles = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: this.config.directory,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            allFiles.push(...matches);
+        }
+        // Deduplicate and sort
+        this.files = [...new Set(allFiles)].sort();
+    }
+    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) : [];
+        const docPath = [...dirParts, parsed.name].join('/');
+        // Derive name from filename
+        const name = parsed.name
+            .split(/[-_]/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+        // Parse into sections
+        const sections = this.parseMarkdownSections(content, path.dirname(fullPath));
+        if (sections.length === 0) {
+            return null;
+        }
+        return {
+            relativePath: docPath,
+            name,
+            sections,
+            sourcePath: relativePath,
+        };
+    }
+    parseMarkdownSections(content, baseDir) {
+        const tree = unified().use(remarkParse).parse(content);
+        const sections = [];
+        let currentSection = null;
+        let pendingContent = [];
+        const flushPendingContent = () => {
+            if (pendingContent.length > 0 && currentSection) {
+                const blocks = this.nodesToContentBlocks(pendingContent, baseDir);
+                currentSection.content.push(...blocks);
+                pendingContent = [];
+            }
+        };
+        for (const node of tree.children) {
+            if (node.type === 'heading') {
+                const heading = node;
+                // H1 becomes document title context, H2+ become sections
+                if (heading.depth === 1) {
+                    // Store H1 content as intro section if we have content before first H2
+                    if (pendingContent.length > 0 && !currentSection) {
+                        const introBlocks = this.nodesToContentBlocks(pendingContent, baseDir);
+                        if (introBlocks.length > 0) {
+                            sections.push({
+                                name: 'Introduction',
+                                content: introBlocks,
+                            });
+                        }
+                        pendingContent = [];
+                    }
+                    continue;
+                }
+                // Flush previous section
+                flushPendingContent();
+                if (currentSection && currentSection.content.length > 0) {
+                    sections.push(currentSection);
+                }
+                // Start new section
+                const sectionName = this.extractText(heading);
+                currentSection = {
+                    name: sectionName,
+                    content: [],
+                };
+            }
+            else {
+                pendingContent.push(node);
+            }
+        }
+        // Flush final section
+        flushPendingContent();
+        if (currentSection && currentSection.content.length > 0) {
+            sections.push(currentSection);
+        }
+        // If no sections created but we have content, create a single section
+        if (sections.length === 0 && tree.children.length > 0) {
+            const blocks = this.nodesToContentBlocks(tree.children, baseDir);
+            if (blocks.length > 0) {
+                sections.push({
+                    name: 'Content',
+                    content: blocks,
+                });
+            }
+        }
+        return sections;
+    }
+    nodesToContentBlocks(nodes, baseDir) {
+        const blocks = [];
+        let textBuffer = '';
+        const flushTextBuffer = () => {
+            if (textBuffer.trim()) {
+                blocks.push({
+                    blockType: 'text',
+                    text: textBuffer.trim(),
+                });
+                textBuffer = '';
+            }
+        };
+        for (const node of nodes) {
+            if (node.type === 'image') {
+                flushTextBuffer();
+                const imageBlock = this.imageToBlock(node, baseDir);
+                if (imageBlock) {
+                    blocks.push(imageBlock);
+                }
+            }
+            else {
+                textBuffer += this.nodeToMarkdown(node) + '\n\n';
+            }
+        }
+        flushTextBuffer();
+        return blocks;
+    }
+    imageToBlock(node, baseDir) {
+        const url = node.url;
+        // Handle external URLs
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            return {
+                blockType: 'image',
+                type: 'url',
+                url,
+                mediaType: this.guessImageType(url),
+                alt: node.alt || undefined,
+            };
+        }
+        // Handle local files
+        const imagePath = path.isAbsolute(url) ? url : path.join(baseDir, url);
+        const ext = path.extname(imagePath).toLowerCase();
+        const mediaType = this.extensionToMediaType(ext);
+        if (!mediaType) {
+            return null;
+        }
+        return {
+            blockType: 'image',
+            type: 'file',
+            path: imagePath,
+            mediaType,
+            alt: node.alt || undefined,
+        };
+    }
+    guessImageType(url) {
+        const ext = path.extname(new URL(url).pathname).toLowerCase();
+        return this.extensionToMediaType(ext) || 'image/png';
+    }
+    extensionToMediaType(ext) {
+        const map = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+        };
+        return map[ext] || null;
+    }
+    extractText(node) {
+        const parts = [];
+        for (const child of node.children) {
+            if ('value' in child) {
+                parts.push(child.value);
+            }
+            else if ('children' in child) {
+                parts.push(this.extractText(child));
+            }
+        }
+        return parts.join('');
+    }
+    nodeToMarkdown(node) {
+        // Simple markdown serialization - could use remark-stringify for more complete solution
+        switch (node.type) {
+            case 'paragraph':
+                return node.children
+                    .map((c) => this.nodeToMarkdown(c))
+                    .join('');
+            case 'text':
+                return node.value;
+            case 'strong':
+                return `**${node.children.map((c) => this.nodeToMarkdown(c)).join('')}**`;
+            case 'emphasis':
+                return `*${node.children.map((c) => this.nodeToMarkdown(c)).join('')}*`;
+            case 'inlineCode':
+                return `\`${node.value}\``;
+            case 'code':
+                const code = node;
+                return `\`\`\`${code.lang || ''}\n${code.value}\n\`\`\``;
+            case 'link':
+                const link = node;
+                const linkText = link.children.map((c) => this.nodeToMarkdown(c)).join('');
+                return `[${linkText}](${link.url})`;
+            case 'list':
+                const list = node;
+                return list.children
+                    .map((item, i) => {
+                    const prefix = list.ordered ? `${i + 1}. ` : '- ';
+                    const content = item.children
+                        .map((c) => this.nodeToMarkdown(c))
+                        .join('');
+                    return prefix + content;
+                })
+                    .join('\n');
+            case 'listItem':
+                return node.children
+                    .map((c) => this.nodeToMarkdown(c))
+                    .join('');
+            case 'blockquote':
+                const quoteContent = node.children
+                    .map((c) => this.nodeToMarkdown(c))
+                    .join('\n');
+                return quoteContent
+                    .split('\n')
+                    .map((line) => `> ${line}`)
+                    .join('\n');
+            case 'heading':
+                const heading = node;
+                const hashes = '#'.repeat(heading.depth);
+                const headingText = heading.children.map((c) => this.nodeToMarkdown(c)).join('');
+                return `${hashes} ${headingText}`;
+            case 'thematicBreak':
+                return '---';
+            case 'table':
+                return this.tableToMarkdown(node);
+            default:
+                return '';
+        }
+    }
+    tableToMarkdown(node) {
+        if (!node.children || node.children.length === 0)
+            return '';
+        const rows = node.children.map((row) => row.children.map((cell) => cell.children.map((c) => this.nodeToMarkdown(c)).join('')));
+        if (rows.length === 0)
+            return '';
+        const header = rows[0];
+        const separator = header.map(() => '---');
+        const body = rows.slice(1);
+        const lines = [
+            '| ' + header.join(' | ') + ' |',
+            '| ' + separator.join(' | ') + ' |',
+            ...body.map((row) => '| ' + row.join(' | ') + ' |'),
+        ];
+        return lines.join('\n');
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Types for the KB migration tool
+ */
+/**
+ * A content block in a section
+ */
+export interface ContentBlock {
+    blockType: 'text' | 'image' | 'document';
+    text?: string;
+    type?: 'base64' | 'url' | 'file';
+    mediaType?: string;
+    path?: string;
+    url?: string;
+    base64?: string;
+    alt?: string;
+    filename?: string;
+}
+/**
+ * A section to be created in a document
+ */
+export interface SectionInput {
+    name: string;
+    content: ContentBlock[];
+}
+/**
+ * A document extracted from a source
+ */
+export interface ExtractedDocument {
+    /** Relative path from source root (e.g., "guides/getting-started") */
+    relativePath: string;
+    /** Document name (derived from filename or metadata) */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Sections extracted from the document */
+    sections: SectionInput[];
+    /** Original source path/identifier for logging */
+    sourcePath: string;
+}
+/**
+ * Status of a single document migration
+ */
+export type MigrationStatus = 'created' | 'updated' | 'skipped' | 'failed';
+/**
+ * Result of migrating a single document
+ */
+export interface MigrationResult {
+    sourcePath: string;
+    documentPath: string;
+    status: MigrationStatus;
+    documentId?: string;
+    branchId?: string;
+    sectionsCount?: number;
+    error?: string;
+    duration?: number;
+}
+/**
+ * Complete migration log for JSON output
+ */
+export interface MigrationLog {
+    timestamp: string;
+    source: {
+        type: string;
+        location: string;
+    };
+    targetApi: string;
+    basePath: string;
+    options: {
+        dryRun: boolean;
+        onConflict: 'skip' | 'update';
+        extensions?: string[];
+    };
+    results: MigrationResult[];
+    summary: {
+        total: number;
+        created: number;
+        updated: number;
+        skipped: number;
+        failed: number;
+        duration: number;
+    };
+}
+/**
+ * Options for migration
+ */
+export interface MigrationOptions {
+    /** API endpoint base URL */
+    apiUrl: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Base path prefix for all documents */
+    basePath: string;
+    /** How to handle existing documents */
+    onConflict: 'skip' | 'update';
+    /** Dry run mode - don't actually create documents */
+    dryRun: boolean;
+    /** Default permission for documents */
+    defaultPermission?: 'edit' | 'read' | 'none';
+    /** AI access permission for documents */
+    aiAccess?: 'edit' | 'read' | 'none';
+}
+/**
+ * Error response from API when document already exists
+ */
+export interface ConflictError {
+    error: string;
+    documentId: string;
+    branchId: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the KB migration tool
+ */
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@moxn/kb-migrate",
+  "version": "0.1.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",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "moxn-kb-migrate": "./bin/moxn-kb-migrate"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "glob": "^10.0.0",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "moxn",
+    "knowledge-base",
+    "migration",
+    "notion",
+    "google-docs",
+    "markdown"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moxn-ai/moxn.git",
+    "directory": "packages/kb-migrate"
+  },
+  "homepage": "https://moxn.dev",
+  "bugs": {
+    "url": "https://github.com/moxn-ai/moxn/issues"
+  },
+  "author": "Moxn <support@moxn.dev>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}