@moxn/kb-migrate 0.4.37 → 0.4.39

package/dist/client.js

@@ -93,6 +93,22 @@ export class MoxnClient {
                     };
                 }
                 catch (updateError) {
+                    // Re-importing BYTE-IDENTICAL content makes the server reject the
+                    // empty commit ("No changes to commit"). For an importer that's a
+                    // NO-OP, not a failure — report a successful (no-op) update, matching
+                    // the grammar path's idempotent re-import. (Audit finding B.)
+                    const msg = updateError instanceof Error ? updateError.message : '';
+                    if (msg.includes('No changes to commit')) {
+                        return {
+                            sourcePath: doc.sourcePath,
+                            documentPath,
+                            status: 'updated',
+                            documentId: error.documentId,
+                            branchId: error.branchId,
+                            sourcePageId: doc.metadata?.notionPageId,
+                            duration: Date.now() - startTime,
+                        };
+                    }
                     return {
                         sourcePath: doc.sourcePath,
                         documentPath,

package/dist/migrate-document.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/migrate-document.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { MoxnClient } from './client.js';
+/** Minimal fetch Response stand-in (client reads .ok/.status/.json()). */
+function mockResponse(status, body) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => body,
+    };
+}
+const doc = {
+    relativePath: 'runbook',
+    name: 'Runbook',
+    sections: [{ name: 'Steps', content: [{ blockType: 'text', text: 'body' }] }],
+    sourcePath: 'notion://x',
+    metadata: { notionPageId: 'p1' },
+};
+function client() {
+    return new MoxnClient({
+        apiUrl: 'http://test',
+        apiKey: 'k',
+        basePath: '/',
+        onConflict: 'update',
+        dryRun: false,
+    });
+}
+afterEach(() => vi.restoreAllMocks());
+describe('migrateDocument — finding B: unchanged re-import is a no-op, not a failure', () => {
+    it("treats the server's 'No changes to commit' on update as a no-op success", async () => {
+        // create → 409 (path exists, id recovered) → update → 400 No-changes.
+        vi.spyOn(globalThis, 'fetch').mockImplementation((async (url, init) => {
+            const u = String(url);
+            const method = (init?.method ?? 'GET').toUpperCase();
+            if (method === 'POST' && u.endsWith('/api/v1/kb/documents')) {
+                return mockResponse(409, {
+                    error: 'exists',
+                    documentId: 'doc-1',
+                    branchId: 'br-1',
+                });
+            }
+            if (method === 'PUT' && u.includes('/api/v1/kb/documents/')) {
+                return mockResponse(400, {
+                    error: 'No changes to commit — working hash equals head body hash',
+                });
+            }
+            return mockResponse(200, {});
+        }));
+        const res = await client().migrateDocument(doc, '/', 'update', false);
+        expect(res.status).toBe('updated'); // NOT 'failed'
+        expect(res.documentId).toBe('doc-1');
+    });
+    it('still reports a genuine update error as failed', async () => {
+        vi.spyOn(globalThis, 'fetch').mockImplementation((async (url, init) => {
+            const u = String(url);
+            const method = (init?.method ?? 'GET').toUpperCase();
+            if (method === 'POST' && u.endsWith('/api/v1/kb/documents')) {
+                return mockResponse(409, {
+                    error: 'exists',
+                    documentId: 'doc-1',
+                    branchId: 'br-1',
+                });
+            }
+            if (method === 'PUT')
+                return mockResponse(500, { error: 'boom' });
+            return mockResponse(200, {});
+        }));
+        const res = await client().migrateDocument(doc, '/', 'update', false);
+        expect(res.status).toBe('failed');
+    });
+});

package/dist/sources/notion.d.ts

@@ -23,6 +23,8 @@ export interface NotionSourceConfig extends SourceConfig {
 export interface PageTreeNode {
     page: NotionPage;
     title: string;
+    /** Disambiguated document name — `slugify(name) === slug` (finding D). May differ from `title` for same-titled siblings. */
+    name: string;
     slug: string;
     children: PageTreeNode[];
     kbPath: string;
@@ -50,6 +52,7 @@ export declare class NotionSource extends MigrationSource<NotionSourceConfig> {
     private allPages;
     private pagePathMap;
     private pageTitleMap;
+    private pageNameMap;
     private databases;
     private databaseEntryPageIds;
     private _documentCount;
@@ -113,6 +116,8 @@ export interface PageTreeResult {
     allPages: PageTreeNode[];
     pagePathMap: PagePathMap;
     pageTitleMap: Map<string, string>;
+    /** nid → disambiguated document name (parallel to pagePathMap; finding D). */
+    pageNameMap: Map<string, string>;
     databaseEntryPageIds: Set<string>;
 }
 /**
@@ -136,3 +141,16 @@ export declare function buildPageTree(pages: NotionPage[], options?: BuildPageTr
  * Falls back to "untitled" when the result is empty (e.g. emoji-only or non-Latin titles).
  */
 export declare function slugify(title: string): string;
+/**
+ * Disambiguate a sibling page whose slug collides with an earlier sibling,
+ * suffixing BOTH the name and the slug so the bijective invariant
+ * `slugify(name) === slug` holds — the server's `createDocumentWithSections`
+ * hard-asserts it (the #177 name/path cutover). The legacy tree builder
+ * suffixed only the PATH (`notes` → `notes-2`) while the name stayed `Notes`,
+ * so a second same-titled sibling was rejected by that assert (audit finding D).
+ * Mutates `siblingSlugCounts` (keyed on the BASE slug) the way the builder expects.
+ */
+export declare function disambiguateSibling(title: string, siblingSlugCounts: Map<string, number>, slugifyFn?: (s: string) => string): {
+    name: string;
+    slug: string;
+};

package/dist/sources/notion.js

@@ -25,6 +25,7 @@ export class NotionSource extends MigrationSource {
     allPages = []; // flat list, depth-first order
     pagePathMap = new Map();
     pageTitleMap = new Map();
+    pageNameMap = new Map();
     databases = [];
     databaseEntryPageIds = new Set();
     _documentCount = 0;
@@ -266,6 +267,7 @@ export class NotionSource extends MigrationSource {
         this.allPages = result.allPages;
         this.pagePathMap = result.pagePathMap;
         this.pageTitleMap = result.pageTitleMap;
+        this.pageNameMap = result.pageNameMap;
         this.databaseEntryPageIds = result.databaseEntryPageIds;
     }
     // ============================================
@@ -326,7 +328,7 @@ export class NotionSource extends MigrationSource {
             }
             return {
                 relativePath: node.kbPath,
-                name: node.title,
+                name: node.name,
                 sections,
                 sourcePath: `notion://${node.page.id}`,
                 references: references.length > 0 ? references : undefined,
@@ -373,7 +375,7 @@ export class NotionSource extends MigrationSource {
             const kbPath = this.pagePathMap.get(nid) ?? slug;
             return {
                 relativePath: kbPath,
-                name: title,
+                name: this.pageNameMap.get(nid) ?? title,
                 sections: processedSections.length > 0
                     ? processedSections
                     : [
@@ -421,6 +423,7 @@ export class NotionSource extends MigrationSource {
 export function buildPageTree(pages, options) {
     const pagePathMap = new Map();
     const pageTitleMap = new Map();
+    const pageNameMap = new Map();
     const databaseEntryPageIds = new Set();
     const tree = [];
     const allPages = [];
@@ -530,18 +533,16 @@ export function buildPageTree(pages, options) {
             return null;
         }
         const title = getPageTitle(page);
-        let slug = slugify(title);
-        // Deduplicate sibling slugs
-        const existing = siblingSlugCounts.get(slug) ?? 0;
-        siblingSlugCounts.set(slug, existing + 1);
-        if (existing > 0) {
-            slug = `${slug}-${existing + 1}`;
-        }
+        // Dedup sibling slugs — suffix BOTH name and slug so slugify(name) === slug
+        // (the server's hard bijection assert; audit finding D). Legacy code
+        // suffixed only the path, so a same-titled sibling was rejected.
+        const { name, slug } = disambiguateSibling(title, siblingSlugCounts);
         const kbPath = parentPath ? `${parentPath}/${slug}` : slug;
         const isDatabaseEntry = databaseEntryPageIds.has(nid);
         const node = {
             page,
             title,
+            name,
             slug,
             kbPath,
             isDatabaseEntry,
@@ -552,6 +553,7 @@ export function buildPageTree(pages, options) {
         // Register in path map and title map
         pagePathMap.set(nid, kbPath);
         pageTitleMap.set(nid, title);
+        pageNameMap.set(nid, name);
         // Process children
         const childPages = childrenByParent.get(nid) ?? [];
         const childSlugCounts = new Map();
@@ -579,7 +581,14 @@ export function buildPageTree(pages, options) {
         }
     };
     flatten(tree);
-    return { tree, allPages, pagePathMap, pageTitleMap, databaseEntryPageIds };
+    return {
+        tree,
+        allPages,
+        pagePathMap,
+        pageTitleMap,
+        pageNameMap,
+        databaseEntryPageIds,
+    };
 }
 /** Extract the parent page ID from a Notion page's parent field. */
 function getParentPageId(page) {
@@ -614,3 +623,21 @@ export function slugify(title) {
         .replace(/^-+|-+$/g, '');
     return cleaned.length > 0 ? cleaned : 'untitled';
 }
+/**
+ * Disambiguate a sibling page whose slug collides with an earlier sibling,
+ * suffixing BOTH the name and the slug so the bijective invariant
+ * `slugify(name) === slug` holds — the server's `createDocumentWithSections`
+ * hard-asserts it (the #177 name/path cutover). The legacy tree builder
+ * suffixed only the PATH (`notes` → `notes-2`) while the name stayed `Notes`,
+ * so a second same-titled sibling was rejected by that assert (audit finding D).
+ * Mutates `siblingSlugCounts` (keyed on the BASE slug) the way the builder expects.
+ */
+export function disambiguateSibling(title, siblingSlugCounts, slugifyFn = slugify) {
+    const baseSlug = slugifyFn(title);
+    const existing = siblingSlugCounts.get(baseSlug) ?? 0;
+    siblingSlugCounts.set(baseSlug, existing + 1);
+    if (existing === 0)
+        return { name: title, slug: baseSlug };
+    const name = `${title} ${existing + 1}`;
+    return { name, slug: slugifyFn(name) };
+}

package/dist/sources/notion.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { slugify } from './notion.js';
+import { slugify, disambiguateSibling } from './notion.js';
 describe('slugify (notion)', () => {
     it('lowercases', () => {
         expect(slugify('MyDoc')).toBe('mydoc');
@@ -43,3 +43,41 @@ describe('slugify (notion)', () => {
         expect(slugify('🎉')).toBe('untitled');
     });
 });
+describe('disambiguateSibling (D — dedup name AND path together)', () => {
+    it('returns the title unchanged for the first occurrence', () => {
+        const counts = new Map();
+        expect(disambiguateSibling('Notes', counts)).toEqual({
+            name: 'Notes',
+            slug: 'notes',
+        });
+    });
+    it('suffixes BOTH name and slug for siblings, keeping the bijection', () => {
+        const counts = new Map();
+        disambiguateSibling('Notes', counts); // first
+        const second = disambiguateSibling('Notes', counts);
+        const third = disambiguateSibling('Notes', counts);
+        expect(second).toEqual({ name: 'Notes 2', slug: 'notes-2' });
+        expect(third).toEqual({ name: 'Notes 3', slug: 'notes-3' });
+        // The invariant the server's assertNamePathConsistent enforces:
+        expect(slugify(second.name)).toBe(second.slug);
+        expect(slugify(third.name)).toBe(third.slug);
+    });
+    it('independent base titles do not collide in the counter', () => {
+        const counts = new Map();
+        expect(disambiguateSibling('Alpha', counts).slug).toBe('alpha');
+        expect(disambiguateSibling('Beta', counts).slug).toBe('beta');
+    });
+});
+describe('disambiguateSibling — custom slugify (OneNote uses slugifyPathSegment)', () => {
+    const upperSlug = (s) => s.toUpperCase().replace(/ /g, '_');
+    it('derives the slug with the provided function, keeping the bijection', () => {
+        const counts = new Map();
+        expect(disambiguateSibling('My Page', counts, upperSlug)).toEqual({
+            name: 'My Page',
+            slug: 'MY_PAGE',
+        });
+        const second = disambiguateSibling('My Page', counts, upperSlug);
+        expect(second).toEqual({ name: 'My Page 2', slug: 'MY_PAGE_2' });
+        expect(upperSlug(second.name)).toBe(second.slug);
+    });
+});

package/dist/sources/onenote/onenote-tree.js

@@ -11,6 +11,7 @@
  * own ID or any ancestor's ID is in the set. If the set is empty, every
  * page is included.
  */
+import { disambiguateSibling } from '../notion.js';
 const MAX_GROUP_DEPTH = 4;
 /**
  * Normalize any human text into a ltree-safe slug segment.
@@ -96,12 +97,22 @@ async function walkSection(client, section, pathSegs, ctx, ancestorSelected, sel
         createdBefore: opts.createdBefore,
     });
     const sectionSeg = slugifyPathSegment(section.displayName);
+    // Dedup same-titled sibling pages within a section — suffix the title AND the
+    // path segment together so slugify(name) === pathTail (the server's hard
+    // bijection assert) and two pages never collide on one path. Without this,
+    // two "Untitled" pages produce the same kbPath → the second silently clobbers
+    // or skips the first on import. (Notion finding D; OneNote had no dedup at all.)
+    const pageSlugCounts = new Map();
     for (const page of pages) {
         const pageSelected = ancestorSelected || (!!sel && sel.has(page.id));
         if (!pageSelected)
             continue;
-        const pageSeg = slugifyPathSegment(page.title ?? 'untitled');
-        out.push(toDiscovered(page, section, [...pathSegs, sectionSeg, pageSeg], ctx));
+        const { name: dedupTitle, slug: pageSeg } = disambiguateSibling(page.title ?? 'untitled', pageSlugCounts, slugifyPathSegment);
+        out.push(toDiscovered({ ...page, title: dedupTitle }, section, [
+            ...pathSegs,
+            sectionSeg,
+            pageSeg,
+        ], ctx));
     }
 }
 function toDiscovered(page, section, segs, ctx) {

package/package.json

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