@moxn/kb-migrate 0.5.0 → 0.6.0

package/dist/output.test.js

@@ -0,0 +1,59 @@
+/**
+ * `--json` output contract + version reporting.
+ *
+ * - `kb-migrate local --json` printed `Processing: …` progress on STDOUT ahead
+ *   of the JSON log, so `context import-local --json` was not parseable. In
+ *   JSON mode stdout carries the log and nothing else; progress goes to stderr.
+ * - `--version` was hardcoded `0.1.0`, so a stale npx resolution (a cached
+ *   0.4.x exporter, prod 2026-09-25) was undiagnosable. The real package
+ *   version is reported, and stamped on every JSON log.
+ */
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import * as fs from 'fs';
+import { emitJson, packageVersion, withJsonStdout } from './output.js';
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('packageVersion', () => {
+    it('is the version in package.json, not a hardcoded placeholder', () => {
+        const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        expect(packageVersion()).toBe(pkg.version);
+        expect(packageVersion()).not.toBe('0.1.0');
+    });
+});
+describe('JSON mode stdout', () => {
+    function capture() {
+        const stdout = [];
+        const stderr = [];
+        vi.spyOn(process.stdout, 'write').mockImplementation(((c) => {
+            stdout.push(String(c));
+            return true;
+        }));
+        vi.spyOn(process.stderr, 'write').mockImplementation(((c) => {
+            stderr.push(String(c));
+            return true;
+        }));
+        return { stdout, stderr };
+    }
+    it('routes progress (console.log) to stderr while the run is in JSON mode', async () => {
+        const { stdout, stderr } = capture();
+        await withJsonStdout(true, async () => {
+            console.log('Processing: a.md (1/1)');
+        });
+        emitJson({ summary: { total: 1 } });
+        const out = stdout.join('');
+        const parsed = JSON.parse(out);
+        expect(parsed.summary.total).toBe(1);
+        expect(parsed.kbMigrateVersion).toBe(packageVersion());
+        expect(out).not.toContain('Processing');
+        expect(stderr.join('')).toContain('Processing: a.md');
+    });
+    it('restores console.log afterwards, and leaves it alone outside JSON mode', async () => {
+        const original = console.log;
+        await withJsonStdout(true, async () => { });
+        expect(console.log).toBe(original);
+        await withJsonStdout(false, async () => {
+            expect(console.log).toBe(original);
+        });
+    });
+});

package/dist/targets/notion.js

@@ -11,6 +11,7 @@
  * Conflict detection uses the MoxnClient's notion-mapping API endpoints
  * (when available) to find existing Notion pages for a KB document.
  */
+import { moxnFetch } from '../http.js';
 import { Client } from '@notionhq/client';
 import { markdownToBlocks } from '@tryfabric/martian';
 import { ExportTarget, } from './base.js';
@@ -744,7 +745,7 @@ export class NotionExportTarget extends ExportTarget {
             return cached;
         // Try notion-mapping API
         try {
-            const response = await fetch(`${this.config.apiUrl}/api/v1/kb/notion-mappings/by-document/${kbDocumentId}`, {
+            const response = await moxnFetch(`${this.config.apiUrl}/api/v1/kb/notion-mappings/by-document/${kbDocumentId}`, {
                 headers: { 'x-api-key': this.config.apiKey },
             });
             if (response.ok) {
@@ -764,7 +765,7 @@ export class NotionExportTarget extends ExportTarget {
         this.mappingCache.set(kbDocumentId, notionPageId);
         // Try to save mapping via API (best-effort)
         try {
-            await fetch(`${this.config.apiUrl}/api/v1/kb/notion-mappings`, {
+            await moxnFetch(`${this.config.apiUrl}/api/v1/kb/notion-mappings`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',

package/dist/types.d.ts

@@ -146,6 +146,8 @@ export interface MigrationResult {
     /** Source page ID (e.g. Notion page ID) for building cross-ref mappings */
     sourcePageId?: string;
     error?: string;
+    /** Non-fatal: the document landed, but not everything asked for applied. */
+    warning?: string;
     duration?: number;
 }
 /**
@@ -276,8 +278,10 @@ export interface ListResponse {
 export interface ExportResult {
     documentId: string;
     documentPath: string;
+    /** Directory-relative output file; empty when nothing was written. */
     outputFile: string;
-    status: 'exported' | 'failed';
+    /** 'skipped': a kind with no local export format (nothing written). */
+    status: 'exported' | 'failed' | 'skipped';
     sectionsCount: number;
     mediaFiles: string[];
     error?: string;
@@ -302,6 +306,7 @@ export interface ExportLog {
         total: number;
         exported: number;
         failed: number;
+        skipped: number;
         mediaDownloaded: number;
         duration: number;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxn/kb-migrate",
-  "version": "0.5.0",
+  "version": "0.6.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",
@@ -112,6 +112,7 @@
   "dependencies": {
     "@azure/msal-node": "^3.8.10",
     "@microsoft/microsoft-graph-client": "^3.0.7",
+    "@moxn/auth": "^0.1.0",
     "@moxn/kb-migrate": "^0.4.14",
     "@notionhq/client": "^5.9.0",
     "@tryfabric/martian": "^1.2.4",