@im-nobsidian/core 0.1.7 → 0.1.8

package/dist/index.js

@@ -3,7 +3,7 @@ import { readFile, mkdir, writeFile, unlink, rename, stat, readdir } from 'fs/pr
 import { join, dirname, relative } from 'path';
 import Database from 'better-sqlite3';
 import { randomUUID, createHash } from 'crypto';
-import { Client } from '@notionhq/client';
+import { Client, LogLevel } from '@notionhq/client';
 import { Sema } from 'async-sema';
 import matter7 from 'gray-matter';
 import { markdownToBlocks } from '@tryfabric/martian';
@@ -290,6 +290,14 @@ CREATE INDEX IF NOT EXISTS idx_file_registry_page ON file_registry(notion_page_i
 UPDATE sync_metadata SET value = '2' WHERE key = 'schema_version';
 `;
 
+// src/state/migrations/003-stat-cache.ts
+var STAT_CACHE_MIGRATION = `
+ALTER TABLE sync_state ADD COLUMN local_mtime TEXT;
+ALTER TABLE sync_state ADD COLUMN local_file_size INTEGER;
+
+UPDATE sync_metadata SET value = '3' WHERE key = 'schema_version';
+`;
+
 // src/state/state-db.ts
 var StateDB = class _StateDB {
   db;
@@ -312,6 +320,9 @@ var StateDB = class _StateDB {
     if (version < 2) {
       this.db.exec(FILE_REGISTRY_MIGRATION);
     }
+    if (version < 3) {
+      this.db.exec(STAT_CACHE_MIGRATION);
+    }
   }
   getSchemaVersion() {
     try {
@@ -349,8 +360,8 @@ var StateDB = class _StateDB {
             notion_page_id = ?, notion_parent_id = ?, content_hash = ?,
             notion_last_edited = ?, local_last_modified = ?,
             sync_direction = ?, file_type = ?, status = ?,
-            base_snapshot = ?, version = version + 1,
-            updated_at = datetime('now')
+            base_snapshot = ?, local_mtime = ?, local_file_size = ?,
+            version = version + 1, updated_at = datetime('now')
           WHERE id = ?`
       ).run(
         record.notionPageId ?? null,
@@ -362,6 +373,8 @@ var StateDB = class _StateDB {
         record.fileType,
         record.status,
         record.baseSnapshot ?? null,
+        record.localMtime ?? null,
+        record.localFileSize ?? null,
         existing.id
       );
       return this.getByPath(record.obsidianPath);
@@ -371,8 +384,8 @@ var StateDB = class _StateDB {
       `INSERT INTO sync_state
           (id, obsidian_path, notion_page_id, notion_parent_id, content_hash,
            notion_last_edited, local_last_modified, sync_direction, file_type,
-           status, base_snapshot, version)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`
+           status, base_snapshot, local_mtime, local_file_size, version)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`
     ).run(
       id,
       record.obsidianPath,
@@ -384,7 +397,9 @@ var StateDB = class _StateDB {
       record.syncDirection,
       record.fileType,
       record.status,
-      record.baseSnapshot ?? null
+      record.baseSnapshot ?? null,
+      record.localMtime ?? null,
+      record.localFileSize ?? null
     );
     return this.getByPath(record.obsidianPath);
   }
@@ -407,6 +422,11 @@ var StateDB = class _StateDB {
       "UPDATE sync_state SET notion_last_edited = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(lastEdited, id);
   }
+  updateStatCache(id, mtime, fileSize) {
+    this.db.prepare(
+      "UPDATE sync_state SET local_mtime = ?, local_file_size = ?, updated_at = datetime('now') WHERE id = ?"
+    ).run(mtime, fileSize, id);
+  }
   setNotionParentId(id, parentId) {
     this.db.prepare(
       "UPDATE sync_state SET notion_parent_id = ?, updated_at = datetime('now') WHERE id = ?"
@@ -520,6 +540,8 @@ var StateDB = class _StateDB {
       fileType: row.file_type,
       status: row.status,
       baseSnapshot: row.base_snapshot,
+      localMtime: row.local_mtime,
+      localFileSize: row.local_file_size,
       version: row.version,
       createdAt: row.created_at,
       updatedAt: row.updated_at
@@ -791,7 +813,8 @@ var NotionClient = class _NotionClient {
   constructor(options) {
     this.client = new Client({
       auth: options.token,
-      timeoutMs: options.timeoutMs ?? 3e4
+      timeoutMs: options.timeoutMs ?? 3e4,
+      logLevel: LogLevel.ERROR
     });
     this.token = options.token;
     this.sema = new Sema(options.concurrency ?? 3);
@@ -1072,6 +1095,30 @@ var NotionClient = class _NotionClient {
       nextCursor: response.next_cursor
     };
   }
+  async searchRecentPages(since) {
+    const results = [];
+    let cursor;
+    const sinceDate = new Date(since);
+    outer: do {
+      const response = await this.withRateLimit(
+        () => this.client.search({
+          filter: { property: "object", value: "page" },
+          sort: { direction: "descending", timestamp: "last_edited_time" },
+          start_cursor: cursor,
+          page_size: 100
+        })
+      );
+      for (const page of response.results) {
+        const p = page;
+        if (new Date(p.last_edited_time) <= sinceDate) {
+          break outer;
+        }
+        results.push({ id: p.id, last_edited_time: p.last_edited_time });
+      }
+      cursor = response.next_cursor ?? void 0;
+    } while (cursor);
+    return results;
+  }
   async getChildPages(parentId) {
     const blocks = await this.fetchAllChildrenDeep(parentId);
     const childPageBlocks = blocks.filter((b) => b.type === "child_page");
@@ -1080,8 +1127,8 @@ var NotionClient = class _NotionClient {
     return pages;
   }
   async getChildDatabaseIds(parentId) {
-    const blocks = await this.fetchAllChildrenDeep(parentId);
-    return blocks.filter((b) => b.type === "child_database").map((b) => b.id);
+    const children = await this.fetchAllChildren(parentId);
+    return children.filter((b) => b.type === "child_database").map((b) => b.id);
   }
   async getChildPagesRecursive(parentId) {
     const all = [];
@@ -1629,6 +1676,52 @@ var ChangeDetector = class {
     this.stateDb = stateDb;
   }
   stateDb;
+  async detectLocalChangesFast(stats, readFile3) {
+    const changes = [];
+    const existingPaths = /* @__PURE__ */ new Set();
+    for (const file of stats) {
+      existingPaths.add(file.path);
+      const record = this.stateDb.getByPath(file.path);
+      if (!record) {
+        const content2 = await readFile3(file.path);
+        changes.push({
+          path: file.path,
+          type: "created",
+          currentHash: computeHash(content2),
+          previousHash: null
+        });
+        continue;
+      }
+      if (record.localMtime === file.mtime && record.localFileSize === file.size) {
+        continue;
+      }
+      const content = await readFile3(file.path);
+      const currentHash = computeHash(content);
+      if (record.contentHash !== currentHash) {
+        changes.push({
+          path: file.path,
+          type: "modified",
+          currentHash,
+          previousHash: record.contentHash
+        });
+      }
+    }
+    const syncedRecords = this.stateDb.getByStatus("synced");
+    for (const record of syncedRecords) {
+      if (!existingPaths.has(record.obsidianPath)) {
+        if (record.fileType === "folder-note" || record.fileType === "folder-only") {
+          if (!record.obsidianPath.endsWith(".md")) continue;
+        }
+        changes.push({
+          path: record.obsidianPath,
+          type: "deleted",
+          currentHash: "",
+          previousHash: record.contentHash
+        });
+      }
+    }
+    return this.detectMoves(changes);
+  }
   detectLocalChanges(currentFiles) {
     const changes = [];
     const existingPaths = /* @__PURE__ */ new Set();
@@ -1644,7 +1737,7 @@ var ChangeDetector = class {
         });
         continue;
       }
-      if (record.localLastModified && file.mtime === record.localLastModified) {
+      if (record.localMtime && record.localMtime === file.mtime) {
         continue;
       }
       const currentHash = computeHash(file.content);
@@ -3215,6 +3308,7 @@ var ImageHandler = class {
         const url = match[2];
         const caption = match[1]?.trim() || "file";
         const download = await this.downloadFile(url, pageTitle, caption);
+        if (!download.localPath) continue;
         downloads.push(download);
         const obsidianLink = `[[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
@@ -3236,6 +3330,7 @@ var ImageHandler = class {
         if (!realUrl) continue;
         const caption = fileName || match[1]?.trim() || "file";
         const download = await this.downloadFile(realUrl, pageTitle, caption);
+        if (!download.localPath) continue;
         downloads.push(download);
         const obsidianLink = `[[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
@@ -3251,6 +3346,7 @@ var ImageHandler = class {
         const url = match[1];
         const caption = match[2]?.trim() || "file";
         const download = await this.downloadFile(url, pageTitle, caption);
+        if (!download.localPath) continue;
         downloads.push(download);
         const obsidianLink = `[[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
@@ -3272,6 +3368,7 @@ var ImageHandler = class {
         if (!realUrl) continue;
         const caption = fileName || match[2]?.trim() || "file";
         const download = await this.downloadFile(realUrl, pageTitle, caption);
+        if (!download.localPath) continue;
         downloads.push(download);
         const obsidianLink = `[[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
@@ -3311,6 +3408,13 @@ var ImageHandler = class {
         if (!response.ok) {
           throw new Error(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
         }
+        const contentLength = response.headers.get("content-length");
+        const MAX_FILE_SIZE = 100 * 1024 * 1024;
+        if (contentLength && parseInt(contentLength, 10) > MAX_FILE_SIZE) {
+          const sizeMB = Math.round(parseInt(contentLength, 10) / 1024 / 1024);
+          getLogger().debug(`[Im-Nobsidian] \uD30C\uC77C \uC2A4\uD0B5 \u2014 \uB108\uBB34 \uD07C (${sizeMB}MB): ${caption}`);
+          return { originalUrl: url, localPath: "", hash: "", size: 0 };
+        }
         const buffer = Buffer.from(await response.arrayBuffer());
         const hash = createHash("sha256").update(buffer).digest("hex").slice(0, 12);
         const extension = this.guessFileExtension(url, response.headers.get("content-type"));
@@ -3469,13 +3573,12 @@ var FileHandler = class {
     if (folderFiles.length === 0) return [];
     const results = [];
     for (const file of folderFiles) {
-      if (this.stateDb.isFileRegistered(file.path)) {
-        const existing = this.stateDb.getFileRegistry(file.path);
-        if (existing) {
-          const buffer = await this.vaultFs.readBinary(file.path);
-          const currentHash = createHash("sha256").update(buffer).digest("hex");
-          if (existing.fileHash === currentHash) continue;
-        }
+      const existing = this.stateDb.getFileRegistry(file.path);
+      if (existing) {
+        if (existing.fileSize === file.size) continue;
+        const buffer = await this.vaultFs.readBinary(file.path);
+        const currentHash = createHash("sha256").update(buffer).digest("hex");
+        if (existing.fileHash === currentHash) continue;
       }
       await this.sema.acquire();
       try {
@@ -3504,19 +3607,20 @@ var FileHandler = class {
       const folderRecord = folderPath ? this.stateDb.getByPath(folderPath) : this.stateDb.getByPath("__root__");
       const folderPageId = folderRecord?.notionPageId;
       if (!folderPageId) {
-        getLogger().warn(
-          `\uD3F4\uB354 \uD398\uC774\uC9C0 \uC5C6\uC74C, \uD30C\uC77C \uC2A4\uD0B5: ${folderPath || "(\uB8E8\uD2B8)"} (${files.length}\uAC1C)`
-        );
+        if (files.length > 0) {
+          getLogger().debug(
+            `\uD3F4\uB354 \uD398\uC774\uC9C0 \uC5C6\uC74C, \uD30C\uC77C \uC2A4\uD0B5: ${folderPath || "(\uB8E8\uD2B8)"} (${files.length}\uAC1C)`
+          );
+        }
         continue;
       }
       for (const file of files) {
-        if (this.stateDb.isFileRegistered(file.path)) {
-          const existing = this.stateDb.getFileRegistry(file.path);
-          if (existing) {
-            const buffer = await this.vaultFs.readBinary(file.path);
-            const currentHash = createHash("sha256").update(buffer).digest("hex");
-            if (existing.fileHash === currentHash) continue;
-          }
+        const existing = this.stateDb.getFileRegistry(file.path);
+        if (existing) {
+          if (existing.fileSize === file.size) continue;
+          const buffer = await this.vaultFs.readBinary(file.path);
+          const currentHash = createHash("sha256").update(buffer).digest("hex");
+          if (existing.fileHash === currentHash) continue;
         }
         await this.sema.acquire();
         try {
@@ -4209,13 +4313,21 @@ var DatabaseSyncer = class {
         });
       }
     }
-    getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
+    getLogger().debug(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
     return { created, updated, failed };
   }
-  async pullDatabaseViews(dbConfig) {
+  async pullDatabaseViews(dbConfig, force = false) {
     try {
-      const viewsConfig = await this.notionClient.getDatabaseViewsConfig(dbConfig.databaseId);
       const configPath = ".im-nobsidian/db-views.json";
+      if (!force) {
+        try {
+          const existing = await this.vaultFs.readFile(configPath);
+          const parsed = JSON.parse(existing);
+          if (parsed[dbConfig.databaseId]) return;
+        } catch {
+        }
+      }
+      const viewsConfig = await this.notionClient.getDatabaseViewsConfig(dbConfig.databaseId);
       await this.vaultFs.ensureFolder(".im-nobsidian");
       let allViewsConfigs = {};
       try {
@@ -4225,7 +4337,7 @@ var DatabaseSyncer = class {
       }
       allViewsConfigs[dbConfig.databaseId] = viewsConfig;
       await this.vaultFs.writeFile(configPath, JSON.stringify(allViewsConfigs, null, 2));
-      getLogger().info(
+      getLogger().debug(
         `[DB Sync] \uBDF0 \uC124\uC815 ${viewsConfig.views.length}\uAC1C \uC800\uC7A5: ${dbConfig.databaseId}`
       );
     } catch (error) {
@@ -4267,15 +4379,32 @@ var DatabaseSyncer = class {
     } catch {
     }
     if (this.config.conversion.imageDownload === "immediate" && markdown) {
-      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
-      markdown = imageResult.content;
+      try {
+        const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+        markdown = imageResult.content;
+      } catch (error) {
+        getLogger().warn(`[DB Sync] \uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 (${title}):`, error);
+      }
     }
     if (markdown) {
-      const fileResult = await this.imageHandler.downloadAllFiles(markdown, title);
-      markdown = fileResult.content;
+      try {
+        const fileResult = await this.imageHandler.downloadAllFiles(markdown, title);
+        markdown = fileResult.content;
+      } catch (error) {
+        getLogger().warn(`[DB Sync] \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 (${title}):`, error);
+      }
     }
     const existingRecord = this.stateDb.getByNotionId(page.id);
-    const filePath = existingRecord?.obsidianPath ?? `${dbConfig.localFolder}/${safeName}.md`;
+    let filePath;
+    if (existingRecord?.obsidianPath) {
+      filePath = existingRecord.obsidianPath;
+    } else {
+      filePath = `${dbConfig.localFolder}/${safeName}.md`;
+      const existingByPath = this.stateDb.getByPath(filePath);
+      if (existingByPath && existingByPath.notionPageId !== page.id) {
+        filePath = `${dbConfig.localFolder}/${safeName} (${page.id.slice(0, 8)}).md`;
+      }
+    }
     const finalContent = this.pipeline.convertToMarkdown(
       markdown,
       {
@@ -4384,7 +4513,7 @@ var DatabaseSyncer = class {
         });
       }
     }
-    getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
+    getLogger().debug(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
     return { created, updated, failed };
   }
 };
@@ -4451,15 +4580,20 @@ var SyncOrchestrator = class {
       return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
     }
     this.cleanupInterruptedSync();
-    const files = await this.vaultFs.listMarkdownFiles();
-    const changes = this.changeDetector.detectLocalChanges(files);
+    this.repairFolderRecords();
+    const stats = await this.vaultFs.listMarkdownFileStats();
+    const changes = await this.changeDetector.detectLocalChangesFast(
+      stats,
+      (path) => this.vaultFs.readFile(path)
+    );
     const conflictPaths = new Set(this.stateDb.getByStatus("conflict").map((r) => r.obsidianPath));
     const eligible = options?.force ? changes : changes.filter((c) => !conflictPaths.has(c.path));
     const dbFolders = (this.config.notion.databases ?? []).map(
       (d) => d.localFolder.endsWith("/") ? d.localFolder : d.localFolder + "/"
     );
     const isDbPath = (path) => dbFolders.some((prefix) => path.startsWith(prefix));
-    const filtered = (options?.paths ? eligible.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : eligible).filter((c) => !isDbPath(c.path));
+    const excludeSet = options?.excludePaths ? new Set(options.excludePaths) : null;
+    const filtered = (options?.paths ? eligible.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : eligible).filter((c) => !isDbPath(c.path) && (!excludeSet || !excludeSet.has(c.path)));
     const hasDbConfigs = (this.config.notion.databases?.length ?? 0) > 0;
     if (filtered.length === 0 && !hasDbConfigs) {
       return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
@@ -4630,11 +4764,37 @@ var SyncOrchestrator = class {
     const conflicts = [];
     const writtenPaths = [];
     const failed = [];
-    const remoteChanges = await this.detectRemoteChanges();
+    const lastPull = this.stateDb.getMeta("last_pull_at") ?? this.stateDb.getMeta("last_sync_at");
+    const trackedCount = this.stateDb.getAll().length;
+    const remoteChanges = !this.isDatabaseMode && lastPull && trackedCount > 0 && !options?.force ? await this.detectRemoteChangesIncremental(lastPull) : await this.detectRemoteChanges();
     const filtered = options?.paths ? remoteChanges.filter((c) => {
       const record = this.stateDb.getByNotionId(c.pageId);
       return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
     }) : remoteChanges;
+    if (filtered.length === 0 && (this.config.notion.databases?.length ?? 0) === 0) {
+      const hasDbResults = await this.pullDiscoveredDatabases(writtenPaths, failed);
+      if (!hasDbResults.created && !hasDbResults.updated) {
+        this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
+        this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
+        this.stateDb.setMeta("pull_in_progress", "");
+        return emptyResult;
+      }
+      this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
+      this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
+      this.stateDb.setMeta("pull_in_progress", "");
+      return {
+        created: hasDbResults.created,
+        updated: hasDbResults.updated,
+        deleted: 0,
+        conflicts: [],
+        writtenPaths,
+        failed,
+        duration: Date.now() - startTime,
+        imageCount: 0,
+        fileCount: 0,
+        linkCount: 0
+      };
+    }
     if (filtered.length === 0) {
       return emptyResult;
     }
@@ -4670,15 +4830,13 @@ var SyncOrchestrator = class {
     const tasks = filtered.map((change) => async () => {
       await sema.acquire();
       try {
-        const record = this.stateDb.getByNotionId(change.pageId);
-        const displayPath = record?.obsidianPath ?? change.pageId;
-        const op = change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update";
-        options?.onProgress?.(++pullCompleted, pullTotal, { path: displayPath, operation: op });
+        let resultPath;
         switch (change.type) {
           case "created": {
             const path = await this.pullCreate(change.pageId);
             writtenPaths.push(path);
             created++;
+            resultPath = path;
             break;
           }
           case "modified": {
@@ -4689,16 +4847,24 @@ var SyncOrchestrator = class {
               writtenPaths.push(result.path);
               updated++;
             }
+            resultPath = result.path;
             break;
           }
           case "deleted": {
+            const record2 = this.stateDb.getByNotionId(change.pageId);
+            resultPath = record2?.obsidianPath;
             const path = await this.pullDelete(change.pageId);
             if (path) {
               deleted++;
+              resultPath = path;
             }
             break;
           }
         }
+        const record = this.stateDb.getByNotionId(change.pageId);
+        const displayPath = resultPath ?? record?.obsidianPath ?? change.pageId;
+        const op = change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update";
+        options?.onProgress?.(++pullCompleted, pullTotal, { path: displayPath, operation: op });
       } catch (error) {
         const record = this.stateDb.getByNotionId(change.pageId);
         failed.push({
@@ -4773,44 +4939,13 @@ var SyncOrchestrator = class {
         getLogger().warn("[Im-Nobsidian] DB Pull \uC911 \uC624\uB958:", error);
       }
     }
-    if (!this.isDatabaseMode) {
-      try {
-        const discoveredDbs = await this.discoverChildDatabases();
-        const configuredIds = new Set(
-          (this.config.notion.databases ?? []).map((d) => d.databaseId.replace(/-/g, ""))
-        );
-        const newDbs = discoveredDbs.filter((db) => !configuredIds.has(db.dbId.replace(/-/g, "")));
-        for (const { dbId, parentPageId } of newDbs) {
-          try {
-            const dbTitle = await this.notionClient.getDatabaseTitle(dbId);
-            const safeName = (dbTitle || dbId.slice(0, 8)).replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-");
-            const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
-            let parentFolder = "databases";
-            if (parentEntry?.obsidianPath) {
-              const parts = parentEntry.obsidianPath.split("/");
-              parts.pop();
-              parentFolder = parts.length > 0 ? parts.join("/") : "databases";
-            }
-            const folderName = `${parentFolder}/${safeName}`;
-            const dbConfig = {
-              databaseId: dbId,
-              localFolder: folderName,
-              titleProperty: "Name"
-            };
-            const dbResult = await this.databaseSyncer.pullDatabase(dbConfig);
-            created += dbResult.created;
-            updated += dbResult.updated;
-            failed.push(...dbResult.failed);
-          } catch (error) {
-            getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
-          }
-        }
-      } catch (error) {
-        getLogger().warn("[Im-Nobsidian] child_database \uC790\uB3D9 \uBC1C\uACAC \uC2E4\uD328:", error);
-      }
+    {
+      const dbDiscovery = await this.pullDiscoveredDatabases(writtenPaths, failed);
+      created += dbDiscovery.created;
+      updated += dbDiscovery.updated;
     }
-    const allSyncedMdPaths = this.stateDb.getAll().filter((r) => r.obsidianPath?.endsWith(".md")).map((r) => r.obsidianPath);
-    const linkCount = await this.resolveNotionLinks(allSyncedMdPaths);
+    const linkTargetPaths = writtenPaths.length > 0 ? writtenPaths : [];
+    const linkCount = linkTargetPaths.length > 0 ? await this.resolveNotionLinks(linkTargetPaths) : 0;
     this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("pull_in_progress", "");
@@ -4832,7 +4967,8 @@ var SyncOrchestrator = class {
     const pullResult = await this.pull(options);
     const pushResult = await this.push({
       ...options,
-      paths: options?.paths
+      paths: options?.paths,
+      excludePaths: pullResult.writtenPaths
     });
     return {
       pull: pullResult,
@@ -4861,6 +4997,34 @@ var SyncOrchestrator = class {
       lastSyncAt
     };
   }
+  async statusLocal() {
+    const stats = await this.vaultFs.listMarkdownFileStats();
+    const localChanges = await this.changeDetector.detectLocalChangesFast(
+      stats,
+      (path) => this.vaultFs.readFile(path)
+    );
+    const conflictRecords = this.stateDb.getByStatus("conflict");
+    const lastSyncAt = this.stateDb.getMeta("last_sync_at");
+    return {
+      localChanges,
+      remoteChanges: [],
+      conflicts: [],
+      conflictRecords,
+      pendingOperations: conflictRecords.length,
+      lastSyncAt
+    };
+  }
+  async fetch() {
+    const startTime = Date.now();
+    const changes = await this.detectRemoteChanges();
+    this.stateDb.setMeta("last_fetch_at", (/* @__PURE__ */ new Date()).toISOString());
+    return {
+      newPages: changes.filter((c) => c.type === "created").length,
+      modifiedPages: changes.filter((c) => c.type === "modified").length,
+      deletedPages: changes.filter((c) => c.type === "deleted").length,
+      duration: Date.now() - startTime
+    };
+  }
   async buildConflictsFromRecords(records, localChanges, remoteChanges) {
     const conflicts = [];
     for (const record of records) {
@@ -4903,25 +5067,97 @@ var SyncOrchestrator = class {
     return this.config.notion.parentMode === "database" && !!this.config.notion.databaseId;
   }
   async discoverChildDatabases() {
-    const rootId = this.config.notion.rootPageId;
     const allDbs = [];
-    let currentLevel = [rootId];
-    while (currentLevel.length > 0) {
-      const nextLevel = [];
-      for (const parentId of currentLevel) {
+    const trackedPages = this.stateDb.getAll().filter((r) => r.notionPageId);
+    const pageIds = [this.config.notion.rootPageId, ...trackedPages.map((r) => r.notionPageId)];
+    const seen = /* @__PURE__ */ new Set();
+    for (const parentId of pageIds) {
+      if (seen.has(parentId)) continue;
+      seen.add(parentId);
+      try {
+        const dbIds = await this.notionClient.getChildDatabaseIds(parentId);
+        for (const dbId of dbIds) {
+          allDbs.push({ dbId, parentPageId: parentId });
+        }
+      } catch {
+      }
+    }
+    return allDbs;
+  }
+  async pullDiscoveredDatabases(writtenPaths, failed) {
+    if (this.isDatabaseMode) return { created: 0, updated: 0 };
+    let created = 0;
+    let updated = 0;
+    try {
+      const cachedRaw = this.stateDb.getMeta("discovered_dbs");
+      let dbConfigs = [];
+      if (cachedRaw) {
         try {
-          const dbIds = await this.notionClient.getChildDatabaseIds(parentId);
-          for (const dbId of dbIds) {
-            allDbs.push({ dbId, parentPageId: parentId });
-          }
-          const childPages = await this.notionClient.getChildPages(parentId);
-          nextLevel.push(...childPages.map((p) => p.id));
+          dbConfigs = JSON.parse(cachedRaw);
         } catch {
+          dbConfigs = [];
         }
       }
-      currentLevel = nextLevel;
+      if (dbConfigs.length === 0) {
+        const discoveredDbs = await this.discoverChildDatabases();
+        const configuredIds = new Set(
+          (this.config.notion.databases ?? []).map((d) => d.databaseId.replace(/-/g, ""))
+        );
+        const newDbs = discoveredDbs.filter((db) => !configuredIds.has(db.dbId.replace(/-/g, "")));
+        for (const { dbId, parentPageId } of newDbs) {
+          try {
+            const dbTitle = await this.notionClient.getDatabaseTitle(dbId);
+            const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
+            let parentFolder = "";
+            if (parentEntry?.obsidianPath) {
+              const obsPath = parentEntry.obsidianPath;
+              if (obsPath.endsWith(".md")) {
+                const parts = obsPath.split("/");
+                parts.pop();
+                parentFolder = parts.length > 0 ? parts.join("/") : obsPath.replace(/\.md$/, "");
+              } else {
+                parentFolder = obsPath;
+              }
+            }
+            let safeName;
+            if (dbTitle) {
+              safeName = dbTitle.replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-");
+            } else {
+              const parentName = parentFolder.split("/").pop() || "";
+              safeName = parentName ? `${parentName}-DB` : `db-${dbId.slice(0, 8)}`;
+            }
+            if (!parentFolder) parentFolder = "databases";
+            dbConfigs.push({
+              databaseId: dbId,
+              localFolder: `${parentFolder}/${safeName}`,
+              titleProperty: "Name"
+            });
+          } catch (error) {
+            getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+          }
+        }
+        if (dbConfigs.length > 0) {
+          this.stateDb.setMeta("discovered_dbs", JSON.stringify(dbConfigs));
+        }
+      }
+      for (const dbConfig of dbConfigs) {
+        try {
+          const dbResult = await this.databaseSyncer.pullDatabase(dbConfig);
+          created += dbResult.created;
+          updated += dbResult.updated;
+          failed.push(...dbResult.failed);
+          if (dbResult.created + dbResult.updated > 0) {
+            const dbPaths = this.stateDb.getByStatus("synced").filter((r) => r.fileType === "db-row").map((r) => r.obsidianPath);
+            writtenPaths.push(...dbPaths.slice(-dbResult.created - dbResult.updated));
+          }
+        } catch (error) {
+          getLogger().warn(`[Im-Nobsidian] DB ${dbConfig.databaseId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+        }
+      }
+    } catch (error) {
+      getLogger().warn("[Im-Nobsidian] child_database \uC790\uB3D9 \uBC1C\uACAC \uC2E4\uD328:", error);
     }
-    return allDbs;
+    return { created, updated };
   }
   async resolveNotionLinks(paths) {
     let totalResolved = 0;
@@ -5015,6 +5251,7 @@ var SyncOrchestrator = class {
     );
     await this.imageHandler.uploadAndAppendImages(page.id, conversionResult.images);
     const hash = computeHash(content);
+    const fileStat = await this.vaultFs.getFileStat(path);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
         obsidianPath: path,
@@ -5026,7 +5263,9 @@ var SyncOrchestrator = class {
         syncDirection: "both",
         fileType: this.isFolderNote(path) ? "folder-note" : "file",
         status: "synced",
-        baseSnapshot: Buffer.from(content, "utf-8")
+        baseSnapshot: Buffer.from(content, "utf-8"),
+        localMtime: fileStat?.mtime ?? null,
+        localFileSize: fileStat?.size ?? null
       });
       const aliases = extractAliases2(conversionResult.properties);
       this.stateDb.upsertWikilink({
@@ -5056,23 +5295,36 @@ var SyncOrchestrator = class {
     });
     await this.pushUpdatePage(record.notionPageId, conversionResult.content, record.baseSnapshot);
     await this.imageHandler.uploadAndAppendImages(record.notionPageId, conversionResult.images);
-    let propsToUpdate = conversionResult.properties;
-    if (this.isDatabaseMode && propsToUpdate && Object.keys(propsToUpdate).length > 0) {
+    let propsToUpdate;
+    if (this.isDatabaseMode && conversionResult.properties && Object.keys(conversionResult.properties).length > 0) {
       await this.ensureDbSchema();
       const title2 = extractTitle(path);
-      propsToUpdate = this.propertyMapper.toNotionProperties(propsToUpdate, title2);
+      propsToUpdate = this.propertyMapper.toNotionProperties(conversionResult.properties, title2);
+    } else if (conversionResult.properties?.title) {
+      const titleStr = String(conversionResult.properties.title);
+      propsToUpdate = {
+        title: { title: [{ text: { content: titleStr } }] }
+      };
     }
+    let lastEditedTime = (/* @__PURE__ */ new Date()).toISOString();
     if (propsToUpdate && Object.keys(propsToUpdate).length > 0) {
-      await this.notionClient.updatePageProperties(record.notionPageId, propsToUpdate);
+      const updatedPage = await this.notionClient.updatePageProperties(
+        record.notionPageId,
+        propsToUpdate
+      );
+      lastEditedTime = updatedPage.last_edited_time;
     }
-    const updatedPage = await this.notionClient.getPage(record.notionPageId);
     const hash = computeHash(content);
+    const fileStat = await this.vaultFs.getFileStat(path);
     const title = extractTitle(path);
     const aliases = extractAliases2(conversionResult.properties);
     this.stateDb.transaction(() => {
       this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
       this.stateDb.updateStatus(record.id, "synced");
-      this.stateDb.setNotionLastEdited(record.id, updatedPage.last_edited_time);
+      this.stateDb.setNotionLastEdited(record.id, lastEditedTime);
+      if (fileStat) {
+        this.stateDb.updateStatCache(record.id, fileStat.mtime, fileStat.size);
+      }
       this.stateDb.storePreserveMarkers(path, conversionResult.preserveMarkers);
       this.stateDb.upsertWikilink({
         obsidianPath: path,
@@ -5166,13 +5418,49 @@ var SyncOrchestrator = class {
     }
     return changes;
   }
+  async detectRemoteChangesIncremental(since) {
+    const changes = [];
+    const recentPages = await this.notionClient.searchRecentPages(since);
+    for (const page of recentPages) {
+      const record = this.stateDb.getByNotionId(page.id);
+      if (!record) {
+        try {
+          const fullPage = await this.notionClient.getPage(page.id);
+          const parentId = await this.extractParentId(fullPage);
+          if (parentId && this.isTrackedParent(parentId)) {
+            changes.push({
+              pageId: page.id,
+              type: "created",
+              lastEdited: page.last_edited_time,
+              previousEdited: null
+            });
+          }
+        } catch {
+        }
+        continue;
+      }
+      if (page.last_edited_time !== record.notionLastEdited) {
+        changes.push({
+          pageId: page.id,
+          type: "modified",
+          lastEdited: page.last_edited_time,
+          previousEdited: record.notionLastEdited
+        });
+      }
+    }
+    return changes;
+  }
+  isTrackedParent(parentId) {
+    if (notionIdsEqual(parentId, this.config.notion.rootPageId)) return true;
+    return !!this.stateDb.getByNotionId(parentId);
+  }
   async pullCreate(pageId) {
     const page = await this.notionClient.getPage(pageId);
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
-    const allChildren = await this.notionClient.fetchAllChildrenDeep(pageId);
-    const hasChildPages = allChildren.some((b) => "type" in b && b.type === "child_page");
+    const firstChildren = await this.notionClient.listChildren(pageId, { pageSize: 100 });
+    const hasChildPages = firstChildren.results.some((b) => "type" in b && b.type === "child_page");
     const markdown = await this.fetchPageMarkdown(pageId);
     const hasContent = markdown.trim().length > 0;
     let filePath;
@@ -5223,6 +5511,7 @@ var SyncOrchestrator = class {
     );
     await this.vaultFs.writeFile(filePath, finalContent);
     const hash = computeHash(finalContent);
+    const pullStat = await this.vaultFs.getFileStat(filePath);
     const resolvedParentId = await this.extractParentId(page);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
@@ -5235,7 +5524,9 @@ var SyncOrchestrator = class {
         syncDirection: "both",
         fileType,
         status: "synced",
-        baseSnapshot: Buffer.from(finalContent, "utf-8")
+        baseSnapshot: Buffer.from(finalContent, "utf-8"),
+        localMtime: pullStat?.mtime ?? null,
+        localFileSize: pullStat?.size ?? null
       });
       const aliases = extractAliases2(properties);
       this.stateDb.upsertWikilink({
@@ -5313,6 +5604,7 @@ var SyncOrchestrator = class {
       }
     }
     await this.vaultFs.writeFile(record.obsidianPath, remoteContent);
+    const updateStat = await this.vaultFs.getFileStat(record.obsidianPath);
     const newHash = computeHash(remoteContent);
     this.stateDb.upsert({
       obsidianPath: record.obsidianPath,
@@ -5324,7 +5616,9 @@ var SyncOrchestrator = class {
       syncDirection: record.syncDirection,
       fileType: record.fileType,
       status: "synced",
-      baseSnapshot: Buffer.from(remoteContent, "utf-8")
+      baseSnapshot: Buffer.from(remoteContent, "utf-8"),
+      localMtime: updateStat?.mtime ?? null,
+      localFileSize: updateStat?.size ?? null
     });
     return { path: record.obsidianPath };
   }
@@ -5341,31 +5635,27 @@ var SyncOrchestrator = class {
     return record.obsidianPath;
   }
   async ensureFolderPage(folderPath) {
-    const existing = this.stateDb.getByPath(folderPath);
-    if (existing?.notionPageId) return;
     const folderNotePath = `${folderPath}/${folderPath.split("/").pop()}.md`;
     const folderNoteRecord = this.stateDb.getByPath(folderNotePath);
-    if (folderNoteRecord?.notionParentId) {
-      this.stateDb.upsert({
-        obsidianPath: folderPath,
-        notionPageId: folderNoteRecord.notionParentId,
-        notionParentId: "",
-        contentHash: "",
-        notionLastEdited: folderNoteRecord.notionLastEdited,
-        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
-        syncDirection: "both",
-        fileType: "folder-note",
-        status: "synced"
-      });
+    if (folderNoteRecord?.notionPageId) {
+      const existing2 = this.stateDb.getByPath(folderPath);
+      if (existing2) this.stateDb.delete(existing2.id);
       return;
     }
+    const existing = this.stateDb.getByPath(folderPath);
+    if (existing?.notionPageId) return;
     const parts = folderPath.split("/");
     const folderName = parts[parts.length - 1];
     let parentId = this.config.notion.rootPageId;
     if (parts.length > 1) {
       const parentPath = parts.slice(0, -1).join("/");
+      await this.ensureFolderPage(parentPath);
+      const parentNotePath = `${parentPath}/${parentPath.split("/").pop()}.md`;
+      const parentNote = this.stateDb.getByPath(parentNotePath);
       const parentRecord = this.stateDb.getByPath(parentPath);
-      if (parentRecord?.notionPageId) {
+      if (parentNote?.notionPageId) {
+        parentId = parentNote.notionPageId;
+      } else if (parentRecord?.notionPageId) {
         parentId = parentRecord.notionPageId;
       }
     }
@@ -5392,8 +5682,26 @@ var SyncOrchestrator = class {
     const folderPath = parts.slice(0, -1).join("/");
     const folderRecord = this.stateDb.getByPath(folderPath);
     if (folderRecord?.notionPageId) return folderRecord.notionPageId;
+    const folderName = parts[parts.length - 2];
+    const folderNotePath = `${folderPath}/${folderName}.md`;
+    const folderNoteRecord = this.stateDb.getByPath(folderNotePath);
+    if (folderNoteRecord?.notionPageId) return folderNoteRecord.notionPageId;
     return this.config.notion.rootPageId;
   }
+  repairFolderRecords() {
+    const allRecords = this.stateDb.getAll();
+    const folderRecords = allRecords.filter(
+      (r) => r.fileType === "folder-note" && !r.obsidianPath.endsWith(".md")
+    );
+    for (const folder of folderRecords) {
+      const folderName = folder.obsidianPath.split("/").pop();
+      const folderNotePath = `${folder.obsidianPath}/${folderName}.md`;
+      const noteRecord = this.stateDb.getByPath(folderNotePath);
+      if (noteRecord?.notionPageId) {
+        this.stateDb.delete(folder.id);
+      }
+    }
+  }
   isFolderNote(filePath) {
     const parts = filePath.split("/");
     if (parts.length < 2) return false;
@@ -5428,17 +5736,14 @@ var SyncOrchestrator = class {
   }
   async pushCreatePage(parentId, parentType, title, markdownContent, properties) {
     if (this.config.conversion.preferMarkdownApi !== false) {
-      try {
-        const enhanced = obsidianToNotionEnhanced(markdownContent);
-        return await this.notionClient.createPageWithMarkdown({
-          parentId,
-          parentType,
-          title,
-          markdown: enhanced,
-          properties
-        });
-      } catch {
-      }
+      const enhanced = obsidianToNotionEnhanced(markdownContent);
+      return await this.notionClient.createPageWithMarkdown({
+        parentId,
+        parentType,
+        title,
+        markdown: enhanced,
+        properties
+      });
     }
     const blocks = this.blockConverter.markdownToNotionBlocks(markdownContent);
     const page = await this.notionClient.createPage({
@@ -5452,27 +5757,11 @@ var SyncOrchestrator = class {
     }
     return page;
   }
-  async pushUpdatePage(pageId, markdownContent, baseSnapshot) {
+  async pushUpdatePage(pageId, markdownContent, _baseSnapshot) {
     if (this.config.conversion.preferMarkdownApi !== false) {
-      try {
-        const enhanced = obsidianToNotionEnhanced(markdownContent);
-        if (baseSnapshot) {
-          const baseEnhanced = obsidianToNotionEnhanced(baseSnapshot.toString("utf-8"));
-          const patches = this.computePatches(baseEnhanced, enhanced);
-          if (patches.length > 0 && patches.length <= 20) {
-            try {
-              await this.notionClient.updatePageMarkdownPartial(pageId, patches);
-              return;
-            } catch {
-              await this.notionClient.replacePageMarkdown(pageId, enhanced);
-              return;
-            }
-          }
-        }
-        await this.notionClient.replacePageMarkdown(pageId, enhanced);
-        return;
-      } catch {
-      }
+      const enhanced = obsidianToNotionEnhanced(markdownContent);
+      await this.notionClient.replacePageMarkdown(pageId, enhanced);
+      return;
     }
     const blocks = this.blockConverter.markdownToNotionBlocks(markdownContent);
     const existingBlocks = await this.notionClient.fetchAllChildren(pageId);
@@ -5491,51 +5780,6 @@ var SyncOrchestrator = class {
       })
     );
   }
-  computePatches(oldContent, newContent) {
-    const oldLines = oldContent.split("\n");
-    const newLines = newContent.split("\n");
-    const patches = [];
-    let i = 0;
-    let j = 0;
-    while (i < oldLines.length && j < newLines.length) {
-      if (oldLines[i] === newLines[j]) {
-        i++;
-        j++;
-        continue;
-      }
-      let oldEnd = i + 1;
-      let newEnd = j + 1;
-      const lookahead = Math.min(10, oldLines.length - i, newLines.length - j);
-      for (let k = 1; k <= lookahead; k++) {
-        if (i + k < oldLines.length && newLines[j] === oldLines[i + k]) {
-          oldEnd = i + k;
-          newEnd = j;
-          break;
-        }
-        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
-          oldEnd = i;
-          newEnd = j + k;
-          break;
-        }
-        oldEnd = i + k;
-        newEnd = j + k;
-      }
-      const oldChunk = oldLines.slice(i, oldEnd).join("\n");
-      const newChunk = newLines.slice(j, newEnd).join("\n");
-      if (oldChunk || newChunk) {
-        patches.push({ oldStr: oldChunk, newStr: newChunk });
-      }
-      i = oldEnd;
-      j = newEnd;
-    }
-    if (i < oldLines.length || j < newLines.length) {
-      patches.push({
-        oldStr: oldLines.slice(i).join("\n"),
-        newStr: newLines.slice(j).join("\n")
-      });
-    }
-    return patches;
-  }
   async fetchPageMarkdown(pageId) {
     if (this.config.conversion.preferMarkdownApi !== false) {
       try {
@@ -5673,6 +5917,20 @@ var NodeVaultFS = class {
     await this.walkDir(this.rootPath, files);
     return files;
   }
+  async listMarkdownFileStats() {
+    const stats = [];
+    await this.walkDirStats(this.rootPath, stats);
+    return stats;
+  }
+  async getFileStat(path) {
+    try {
+      const fullPath = join(this.rootPath, path);
+      const fileStat = await stat(fullPath);
+      return { path, mtime: fileStat.mtime.toISOString(), size: fileStat.size };
+    } catch {
+      return null;
+    }
+  }
   async listNonMarkdownFiles() {
     const files = [];
     await this.walkDirNonMd(this.rootPath, files);
@@ -5719,6 +5977,25 @@ var NodeVaultFS = class {
       }
     }
   }
+  async walkDirStats(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDirStats(fullPath, result);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          mtime: fileStat.mtime.toISOString(),
+          size: fileStat.size
+        });
+      }
+    }
+  }
   async walkDir(dir, result) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {