@im-nobsidian/core 0.1.0 → 0.1.1

package/dist/index.js

@@ -366,6 +366,11 @@ var StateDB = class _StateDB {
       ).run(hash, id);
     }
   }
+  setNotionLastEdited(id, lastEdited) {
+    this.db.prepare(
+      "UPDATE sync_state SET notion_last_edited = ?, updated_at = datetime('now') WHERE id = ?"
+    ).run(lastEdited, id);
+  }
   delete(id) {
     this.db.prepare("DELETE FROM sync_state WHERE id = ?").run(id);
   }
@@ -640,6 +645,7 @@ var NotionClient = class {
   getInternalClient() {
     return this.client;
   }
+  // ─── Page CRUD ───
   async getPage(pageId) {
     return this.withRateLimit(
       () => this.client.pages.retrieve({ page_id: pageId })
@@ -658,6 +664,19 @@ var NotionClient = class {
       })
     );
   }
+  async createPageWithMarkdown(params) {
+    const parent = params.parentType === "database" ? { database_id: params.parentId } : { page_id: params.parentId };
+    const properties = params.parentType === "page" ? { title: { title: [{ text: { content: params.title } }] } } : params.properties ?? {
+      title: { title: [{ text: { content: params.title } }] }
+    };
+    return this.withRateLimit(
+      () => this.client.pages.create({
+        parent,
+        properties,
+        markdown: params.markdown
+      })
+    );
+  }
   async updatePageProperties(pageId, properties) {
     return this.withRateLimit(
       () => this.client.pages.update({
@@ -666,6 +685,23 @@ var NotionClient = class {
       })
     );
   }
+  // ─── Markdown API ───
+  async getPageMarkdown(pageId) {
+    return this.withRateLimit(() => this.client.pages.retrieveMarkdown({ page_id: pageId }));
+  }
+  async replacePageMarkdown(pageId, markdown) {
+    return this.withRateLimit(
+      () => this.client.pages.updateMarkdown({
+        page_id: pageId,
+        type: "replace_content",
+        replace_content: {
+          new_str: markdown,
+          allow_deleting_content: true
+        }
+      })
+    );
+  }
+  // ─── Database / DataSource ───
   async getDatabaseSchema(databaseId) {
     const db = await this.withRateLimit(
       () => this.client.databases.retrieve({ database_id: databaseId })
@@ -679,8 +715,8 @@ var NotionClient = class {
   }
   async queryDatabase(databaseId, options) {
     const response = await this.withRateLimit(
-      () => this.client.databases.query({
-        database_id: databaseId,
+      () => this.client.dataSources.query({
+        data_source_id: databaseId,
         start_cursor: options?.startCursor,
         page_size: options?.pageSize ?? 100
       })
@@ -693,6 +729,7 @@ var NotionClient = class {
   async archivePage(pageId) {
     await this.withRateLimit(() => this.client.pages.update({ page_id: pageId, archived: true }));
   }
+  // ─── Block CRUD ───
   async listChildren(blockId, options) {
     const response = await this.withRateLimit(
       () => this.client.blocks.children.list({
@@ -731,6 +768,24 @@ var NotionClient = class {
   async deleteBlock(blockId) {
     await this.withRateLimit(() => this.client.blocks.delete({ block_id: blockId }));
   }
+  // ─── File Upload ───
+  async uploadFile(fileData, filename, contentType) {
+    const upload = await this.withRateLimit(
+      () => this.client.fileUploads.create({ filename, content_type: contentType })
+    );
+    const fileUploadId = upload.id;
+    await this.withRateLimit(
+      () => this.client.fileUploads.send({
+        file_upload_id: fileUploadId,
+        file: { data: fileData, filename }
+      })
+    );
+    await this.withRateLimit(
+      () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
+    );
+    return fileUploadId;
+  }
+  // ─── Search & Navigation ───
   async search(params) {
     const response = await this.withRateLimit(
       () => this.client.search({
@@ -768,11 +823,13 @@ var NotionClient = class {
     }
     return all;
   }
+  // ─── Property Extraction ───
   extractTitle(page) {
-    for (const prop of Object.values(page.properties)) {
-      if (prop.type === "title" && "title" in prop) {
-        const titleArr = prop.title;
-        if (titleArr[0]?.plain_text) return titleArr[0].plain_text;
+    const props = page.properties;
+    for (const prop of Object.values(props)) {
+      if (prop.type === "title" && prop.title) {
+        const joined = prop.title.map((t) => t.plain_text ?? "").join("");
+        if (joined) return joined;
       }
     }
     return "\uC81C\uBAA9 \uC5C6\uC74C";
@@ -780,6 +837,7 @@ var NotionClient = class {
   extractProperties(page) {
     return this.propertyMapper.fromNotionProperties(page.properties);
   }
+  // ─── Internal ───
   async withRateLimit(fn) {
     await this.sema.acquire();
     try {
@@ -792,7 +850,7 @@ var NotionClient = class {
     try {
       return await fn();
     } catch (error) {
-      if (isRateLimited(error) && attempt < 5) {
+      if (isRetryable(error) && attempt < 5) {
         const baseDelay = extractRetryAfter(error) ?? 1e3 * Math.pow(2, attempt);
         const jitter = baseDelay * (0.5 + Math.random() * 0.5);
         await sleep(jitter);
@@ -802,13 +860,20 @@ var NotionClient = class {
     }
   }
 };
-function isRateLimited(error) {
-  return typeof error === "object" && error !== null && "status" in error && error.status === 429;
+function isRetryable(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const code = error.code;
+  if (code === "notionhq_client_request_timeout" || code === "ECONNRESET" || code === "ETIMEDOUT") {
+    return true;
+  }
+  if (!("status" in error)) return false;
+  const status = error.status;
+  return status === 429 || status === 502 || status === 503 || status === 504;
 }
 function extractRetryAfter(error) {
   if (typeof error === "object" && error !== null && "headers" in error) {
     const headers = error.headers;
-    const retryAfter = headers["retry-after"];
+    const retryAfter = headers?.["retry-after"];
     if (retryAfter) return Number(retryAfter) * 1e3;
   }
   return null;
@@ -1187,6 +1252,9 @@ var ChangeDetector = class {
     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",
@@ -1314,17 +1382,11 @@ var ConversionPipeline = class {
     return input.content;
   }
 };
-var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
-var WIKILINK_IN_YAML = /\[\[([^\]]+)\]\]/g;
 var FrontmatterExtractor = class {
   name = "FrontmatterExtractor";
   order = 10;
   process(input) {
-    const sanitized = input.content.replace(FRONTMATTER_REGEX, (match, yaml) => {
-      const fixed = yaml.replace(WIKILINK_IN_YAML, "$1");
-      return match.replace(yaml, fixed);
-    });
-    const { data, content } = matter(sanitized);
+    const { data, content } = matter(input.content);
     return {
       content: content.trim(),
       metadata: {
@@ -1336,21 +1398,41 @@ var FrontmatterExtractor = class {
 };
 
 // src/converter/pre-processors/wikilink.ts
-var WIKILINK_REGEX = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+var WIKILINK_REGEX = /(?<!!)\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
 var WikilinkResolver = class {
+  constructor(resolve) {
+    this.resolve = resolve;
+  }
+  resolve;
   name = "WikilinkResolver";
   order = 20;
   process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const preserveMarkers = input.metadata.preserveMarkers ? [...input.metadata.preserveMarkers] : [];
     const resolved = input.content.replace(
       WIKILINK_REGEX,
       (_match, target, display) => {
         const label = display ?? target;
-        return `**${label}**`;
+        if (this.resolve) {
+          const entry = this.resolve(target);
+          if (entry) {
+            return `<mention-page id="${entry.notionPageId}">${label}</mention-page>`;
+          }
+        }
+        preserveMarkers.push({
+          type: "wikilink",
+          params: display ? { text: target, display } : { text: target },
+          startIndex: 0
+        });
+        const encodedTarget = encodeURIComponent(target);
+        return `[${label}](im-nobsidian://wikilink/${encodedTarget})`;
       }
     );
     return {
       content: resolved,
-      metadata: input.metadata
+      metadata: { ...input.metadata, preserveMarkers }
     };
   }
 };
@@ -1383,13 +1465,17 @@ var CalloutTransformer = class {
   name = "CalloutTransformer";
   order = 30;
   process(input) {
+    if (input.context.path === "markdown-api") {
+      return { content: input.content, metadata: input.metadata };
+    }
     const content = input.content.replace(
       CALLOUT_REGEX,
       (_match, type, foldable, title) => {
         const emoji = CALLOUT_EMOJI_MAP[type.toLowerCase()] ?? "\u{1F4DD}";
         const titleText = title?.trim() || type;
         const foldMeta = foldable ? `
-%% im-nobsidian:callout:type=${type}&foldable=${foldable === "+" ? "open" : "closed"} %%` : "";
+%% im-nobsidian:callout:type=${type}&foldable=${foldable === "+" ? "open" : "closed"} %%` : `
+%% im-nobsidian:callout:type=${type} %%`;
         return `> ${emoji} **${titleText}**${foldMeta}`;
       }
     );
@@ -1438,12 +1524,13 @@ var EmbedResolver = class {
         images.push({ url: target, localPath: target, isExternal: false });
         if (isPush && !isExternalUrl(target)) {
           const fileName = target.split("/").pop() ?? target;
-          return `> \u{1F4CE} ${fileName} (\uB85C\uCEEC \uC774\uBBF8\uC9C0 \u2014 Notion API \uC81C\uD55C\uC73C\uB85C \uC5C5\uB85C\uB4DC \uBD88\uAC00)
+          return `> \u{1F4CE} ${fileName}
 > %% im-nobsidian:local-image:${target} %%`;
         }
         return `![${target}](${encodeURI(target)})`;
       }
-      return `[${target}](${encodeURI(target)})`;
+      const encoded = encodeURIComponent(target);
+      return `[${target}](im-nobsidian://embed/${encoded})`;
     });
     content = content.replace(MARKDOWN_IMAGE_REGEX, (_match, alt, url) => {
       if (isVideoUrl(url)) {
@@ -1519,8 +1606,6 @@ var UnsupportedBlockStripper = class {
     };
   }
 };
-
-// src/converter/pre-processors/properties-table.ts
 var PropertiesTableInjector = class {
   name = "PropertiesTableInjector";
   order = 15;
@@ -1535,32 +1620,20 @@ var PropertiesTableInjector = class {
     if (!properties || Object.keys(properties).length === 0) {
       return { content: input.content, metadata: input.metadata };
     }
-    const filteredEntries = Object.entries(properties).filter(([key]) => key !== "title");
-    if (filteredEntries.length === 0) {
+    const filteredProps = {};
+    for (const [key, value] of Object.entries(properties)) {
+      filteredProps[key] = value;
+    }
+    if (Object.keys(filteredProps).length === 0) {
       return { content: input.content, metadata: input.metadata };
     }
-    const rows = filteredEntries.map(([key, value]) => {
-      const display = formatValue(value);
-      return `| ${key} | ${display} |`;
-    });
-    const table = ["| Property | Value |", "| --- | --- |", ...rows].join("\n");
-    const content = table + "\n\n---\n\n" + input.content;
+    const yamlStr = matter.stringify("", filteredProps).trim();
+    const yamlBody = yamlStr.slice(4, -3).trim();
+    const codeBlock = "```yaml\n# im-nobsidian:properties\n" + yamlBody + "\n```";
+    const content = codeBlock + "\n\n---\n\n" + input.content;
     return { content, metadata: input.metadata };
   }
 };
-function formatValue(value) {
-  if (value === null || value === void 0) return "";
-  if (value instanceof Date) {
-    return value.toISOString().replace(/T00:00:00(?:\.000)?Z$/, "");
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => formatValue(v)).join(", ");
-  }
-  if (typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
 
 // src/converter/pre-processors/html-annotation.ts
 var UNDERLINE_REGEX = /<u>([\s\S]*?)<\/u>/g;
@@ -1582,21 +1655,30 @@ var HtmlAnnotationStripper = class {
 };
 
 // src/converter/post-processors/mention-to-wikilink.ts
-var NOTION_LINK_REGEX = /\[([^\]]+)\]\((?:https:\/\/www\.notion\.so\/|notion:\/\/)([a-f0-9-]+)\)/g;
+var NOTION_LINK_REGEX = /\[([^\]]+)\]\((?:https:\/\/(?:www\.)?notion\.so\/|notion:\/\/)([a-f0-9-]+)\)/g;
+var WIKILINK_PRESERVE_REGEX = /\[([^\]]+)\]\(im-nobsidian:\/\/wikilink\/([^)]+)\)/g;
+var EMBED_PRESERVE_REGEX = /\[([^\]]+)\]\(im-nobsidian:\/\/embed\/([^)]+)\)/g;
 var MentionToWikilink = class {
   name = "MentionToWikilink";
   order = 10;
   process(input) {
-    const content = input.content.replace(
-      NOTION_LINK_REGEX,
-      (_match, display, _pageId) => {
-        return `[[${display}]]`;
+    let content = input.content;
+    content = content.replace(NOTION_LINK_REGEX, (_match, display) => `[[${display}]]`);
+    content = content.replace(
+      WIKILINK_PRESERVE_REGEX,
+      (_match, display, encodedTarget) => {
+        const target = decodeURIComponent(encodedTarget);
+        return target === display ? `[[${target}]]` : `[[${target}|${display}]]`;
       }
     );
-    return {
-      content,
-      metadata: input.metadata
-    };
+    content = content.replace(
+      EMBED_PRESERVE_REGEX,
+      (_match, _display, encodedTarget) => {
+        const target = decodeURIComponent(encodedTarget);
+        return `![[${target}]]`;
+      }
+    );
+    return { content, metadata: input.metadata };
   }
 };
 
@@ -1643,15 +1725,18 @@ var EMOJI_TYPE_MAP = {
   "\u{1F4CC}": "example",
   "\u{1F4AC}": "quote"
 };
-var CALLOUT_PRESERVE_REGEX = /%% im-nobsidian:callout:type=(\w+)&foldable=(open|closed) %%/g;
+var CALLOUT_PRESERVE_REGEX = /%% im-nobsidian:callout:type=(\w+)(?:&foldable=(open|closed))? %%/g;
 var CalloutRestorer = class {
   name = "CalloutRestorer";
   order = 20;
   process(input) {
     let content = input.content;
     content = content.replace(CALLOUT_PRESERVE_REGEX, (_match, type, foldable) => {
-      const foldChar = foldable === "open" ? "+" : "-";
-      return `[!${type}]${foldChar}`;
+      if (foldable) {
+        const foldChar = foldable === "open" ? "+" : "-";
+        return `[!${type}]${foldChar}`;
+      }
+      return `[!${type}]`;
     });
     for (const [emoji, type] of Object.entries(EMOJI_TYPE_MAP)) {
       const pattern = new RegExp(`> ${escapeRegex(emoji)} \\*\\*(.+?)\\*\\*`, "g");
@@ -1722,9 +1807,8 @@ var LocalImageRestorer = class {
     return { content, metadata: input.metadata };
   }
 };
-
-// src/converter/post-processors/properties-table-restorer.ts
-var PROPERTIES_TABLE_REGEX = /^\s*\| Property\s*\| Value\s*\|\n\s*\|\s*-{3,}\s*\|\s*-{3,}\s*\|\n((?:\|[^\n]+\|\n?)+)\n*---\n*/;
+var YAML_PROPERTIES_REGEX = /```yaml\n# im-nobsidian:properties\n([\s\S]*?)```\n*(?:---\n*)?/;
+var LEGACY_TABLE_REGEX = /^\s*\| Property\s*\| Value\s*\|\n\s*\|\s*-{3,}\s*\|\s*-{3,}\s*\|\n((?:\|[^\n]+\|\n?)+)\n*---\n*/;
 var PropertiesTableRestorer = class {
   name = "PropertiesTableRestorer";
   order = 5;
@@ -1732,10 +1816,39 @@ var PropertiesTableRestorer = class {
     if (input.context.direction !== "pull") {
       return { content: input.content, metadata: input.metadata };
     }
-    const match = input.content.match(PROPERTIES_TABLE_REGEX);
-    if (!match) {
+    const yamlMatch = input.content.match(YAML_PROPERTIES_REGEX);
+    if (yamlMatch) {
+      return this.restoreFromYaml(input, yamlMatch);
+    }
+    const tableMatch = input.content.match(LEGACY_TABLE_REGEX);
+    if (tableMatch) {
+      return this.restoreFromTable(input, tableMatch);
+    }
+    return { content: input.content, metadata: input.metadata };
+  }
+  restoreFromYaml(input, match) {
+    const yamlContent = match[1];
+    const fakeDocument = `---
+${yamlContent}---
+`;
+    let parsed;
+    try {
+      const result = matter(fakeDocument);
+      parsed = result.data;
+    } catch {
       return { content: input.content, metadata: input.metadata };
     }
+    const properties = {
+      ...input.metadata.properties,
+      ...parsed
+    };
+    const content = input.content.replace(YAML_PROPERTIES_REGEX, "").trimStart();
+    return {
+      content,
+      metadata: { ...input.metadata, properties }
+    };
+  }
+  restoreFromTable(input, match) {
     const rows = match[1].trim().split("\n");
     const properties = {
       ...input.metadata.properties
@@ -1745,31 +1858,21 @@ var PropertiesTableRestorer = class {
       if (cells.length >= 2) {
         const key = cells[0];
         const rawValue = cells[1];
-        properties[key] = parseValue(rawValue);
+        properties[key] = parseLegacyValue(rawValue);
       }
     }
-    const content = input.content.replace(PROPERTIES_TABLE_REGEX, "").trimStart();
+    const content = input.content.replace(LEGACY_TABLE_REGEX, "").trimStart();
     return {
       content,
       metadata: { ...input.metadata, properties }
     };
   }
 };
-function stripQuotes(s) {
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/;
-function parseValue(raw) {
+function parseLegacyValue(raw) {
   if (raw === "" || raw === "null") return null;
   if (raw === "true") return true;
   if (raw === "false") return false;
   const unquoted = stripQuotes(raw);
-  if (ISO_DATE_REGEX.test(unquoted)) {
-    return unquoted.replace(/T00:00:00(?:\.000)?Z?$/, "");
-  }
   const num = Number(unquoted);
   if (!isNaN(num) && unquoted.trim() !== "") return num;
   if (unquoted.includes(", ")) {
@@ -1791,15 +1894,21 @@ function parseValue(raw) {
   }
   return unquoted;
 }
+function stripQuotes(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
 
 // src/converter/pipeline-factory.ts
-function createDefaultPipeline() {
+function createDefaultPipeline(options) {
   const pipeline = new ConversionPipeline();
   pipeline.registerPreProcessor(new HtmlAnnotationStripper());
   pipeline.registerPreProcessor(new UnsupportedBlockStripper());
   pipeline.registerPreProcessor(new FrontmatterExtractor());
   pipeline.registerPreProcessor(new PropertiesTableInjector());
-  pipeline.registerPreProcessor(new WikilinkResolver());
+  pipeline.registerPreProcessor(new WikilinkResolver(options?.wikilinkResolver));
   pipeline.registerPreProcessor(new CalloutTransformer());
   pipeline.registerPreProcessor(new MathNormalizer());
   pipeline.registerPreProcessor(new EmbedResolver());
@@ -2127,7 +2236,8 @@ ${COLUMN_LIST_END}`;
   markdownToNotionBlocks(markdown) {
     const preprocessed = this.preProcessMarkdown(markdown);
     const blocks = markdownToBlocks(preprocessed);
-    return this.postProcessBlocks(blocks);
+    const processed = this.postProcessBlocks(blocks);
+    return normalizeBlocksForNotion(processed);
   }
   toggleContents = /* @__PURE__ */ new Map();
   columnContents = /* @__PURE__ */ new Map();
@@ -2345,6 +2455,111 @@ ${COLUMN_LIST_END}`;
     return result.parent ?? "";
   }
 };
+var NOTION_MAX_TABLE_ROWS = 100;
+var NOTION_MAX_LIST_DEPTH = 3;
+function normalizeBlocksForNotion(blocks) {
+  const result = [];
+  for (const block of blocks) {
+    if (block.type === "table") {
+      result.push(...normalizeTable(block));
+    } else if (isListBlock(block)) {
+      result.push(flattenListDepth(block, 0));
+    } else {
+      result.push(block);
+    }
+  }
+  return result;
+}
+function normalizeTable(block) {
+  const table = block.table;
+  if (!table?.children) return [block];
+  const rows = table.children;
+  if (rows.length === 0) return [block];
+  let maxCells = table.table_width;
+  for (const row of rows) {
+    const tr = row.table_row;
+    if (tr?.cells && tr.cells.length > maxCells) {
+      maxCells = tr.cells.length;
+    }
+  }
+  const normalizedRows = rows.map((row) => {
+    const tr = row.table_row;
+    if (!tr?.cells) return row;
+    const cells = [...tr.cells];
+    while (cells.length < maxCells) {
+      cells.push([{ type: "text", text: { content: "" } }]);
+    }
+    if (cells.length > maxCells) {
+      cells.length = maxCells;
+    }
+    return { ...row, table_row: { ...tr, cells } };
+  });
+  if (normalizedRows.length <= NOTION_MAX_TABLE_ROWS) {
+    return [
+      {
+        ...block,
+        table: { ...table, table_width: maxCells, children: normalizedRows }
+      }
+    ];
+  }
+  const tables = [];
+  const headerRow = table.has_column_header ? normalizedRows[0] : null;
+  const dataRows = table.has_column_header ? normalizedRows.slice(1) : normalizedRows;
+  const chunkSize = headerRow ? NOTION_MAX_TABLE_ROWS - 1 : NOTION_MAX_TABLE_ROWS;
+  for (let i = 0; i < dataRows.length; i += chunkSize) {
+    const chunk = dataRows.slice(i, i + chunkSize);
+    const children = headerRow ? [headerRow, ...chunk] : chunk;
+    tables.push({
+      type: "table",
+      table: {
+        table_width: maxCells,
+        has_column_header: !!headerRow,
+        has_row_header: table.has_row_header,
+        children
+      }
+    });
+  }
+  return tables;
+}
+function isListBlock(block) {
+  return block.type === "bulleted_list_item" || block.type === "numbered_list_item" || block.type === "to_do";
+}
+function flattenListDepth(block, depth) {
+  const blockType = block.type;
+  const blockData = block[blockType];
+  if (!blockData?.children || blockData.children.length === 0) return block;
+  if (depth >= NOTION_MAX_LIST_DEPTH - 1) {
+    const flattened = collectAllDescendants(blockData.children);
+    return {
+      ...block,
+      [blockType]: { ...blockData, children: flattened }
+    };
+  }
+  const normalizedChildren = blockData.children.map((child) => {
+    if (isListBlock(child)) {
+      return flattenListDepth(child, depth + 1);
+    }
+    return child;
+  });
+  return {
+    ...block,
+    [blockType]: { ...blockData, children: normalizedChildren }
+  };
+}
+function collectAllDescendants(blocks) {
+  const result = [];
+  for (const block of blocks) {
+    const blockType = block.type;
+    const blockData = block[blockType];
+    const children = blockData?.children;
+    const blockWithoutChildren = children ? { ...block, [blockType]: { ...blockData, children: void 0 } } : block;
+    result.push(blockWithoutChildren);
+    if (children && children.length > 0) {
+      result.push(...collectAllDescendants(children));
+    }
+  }
+  return result;
+}
 var IMAGE_EXTENSIONS = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
@@ -2354,13 +2569,26 @@ var IMAGE_EXTENSIONS = {
   "image/bmp": ".bmp",
   "image/tiff": ".tiff"
 };
+var EXTENSION_TO_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".tiff": "image/tiff"
+};
 var ImageHandler = class {
-  constructor(vaultFs, attachmentFolder = "attachments") {
+  constructor(vaultFs, attachmentFolder = "attachments", notionClient) {
     this.vaultFs = vaultFs;
     this.attachmentFolder = attachmentFolder;
+    this.notionClient = notionClient;
   }
   vaultFs;
   attachmentFolder;
+  notionClient;
   async downloadImage(url, pageTitle) {
     const response = await fetch(url);
     if (!response.ok) {
@@ -2414,6 +2642,54 @@ var ImageHandler = class {
     }
     return { content: result, downloads };
   }
+  async uploadLocalImage(localPath) {
+    if (!this.notionClient) {
+      throw new Error("NotionClient required for image upload");
+    }
+    const buffer = await this.readImageFromVault(localPath);
+    const filename = localPath.split("/").pop() ?? "image.png";
+    const contentType = this.getContentTypeFromPath(filename);
+    const blob = new Blob([buffer], { type: contentType });
+    const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
+    return { localPath, fileUploadId };
+  }
+  async uploadAndAppendImages(pageId, images) {
+    if (!this.notionClient) return [];
+    const localImages = images.filter((img) => !img.isExternal && img.localPath);
+    if (localImages.length === 0) return [];
+    const results = [];
+    const imageBlocks = [];
+    for (const img of localImages) {
+      try {
+        const result = await this.uploadLocalImage(img.localPath);
+        results.push(result);
+        imageBlocks.push({
+          type: "image",
+          image: {
+            type: "file_upload",
+            file_upload: { id: result.fileUploadId }
+          }
+        });
+      } catch (error) {
+        getLogger().warn(`\uC774\uBBF8\uC9C0 \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${img.localPath}):`, error);
+      }
+    }
+    if (imageBlocks.length > 0) {
+      await this.notionClient.appendChildren(pageId, imageBlocks);
+    }
+    return results;
+  }
+  async readImageFromVault(localPath) {
+    try {
+      return await this.vaultFs.readBinary(localPath);
+    } catch {
+      return await this.vaultFs.readBinary(`${this.attachmentFolder}/${localPath}`);
+    }
+  }
+  getContentTypeFromPath(filename) {
+    const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+    return (ext && EXTENSION_TO_MIME[ext]) ?? "application/octet-stream";
+  }
   isNotionImageUrl(url) {
     return url.includes("secure.notion-static.com") || url.includes("prod-files-secure") || url.includes("s3.us-west-2.amazonaws.com/secure.notion-static.com");
   }
@@ -2462,6 +2738,257 @@ function sanitizeFileName(name) {
   return sanitized;
 }
 
+// src/converter/enhanced-md-converter.ts
+var NOTION_CALLOUT_RE = /^::: callout\n([\s\S]*?)\n:::/gm;
+var NOTION_TOGGLE_RE = /<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gs;
+var NOTION_PAGE_MENTION_RE = /<mention-page id="([^"]+)">([\s\S]*?)<\/mention-page>/g;
+var NOTION_USER_MENTION_RE = /<mention-user id="[^"]*">([^<]*)<\/mention-user>/g;
+var NOTION_DATE_MENTION_RE = /<mention-date start="([^"]*)"(?: end="([^"]*)")?[^>]*\/>/g;
+var NOTION_UNKNOWN_RE = /<unknown id="[^"]*"[^>]*\/>/g;
+var TOGGLE_START2 = "%%im-nobsidian:toggle:start%%";
+var TOGGLE_END2 = "%%im-nobsidian:toggle:end%%";
+function notionEnhancedToObsidian(enhanced) {
+  let result = enhanced;
+  result = convertToggles(result);
+  result = convertCallouts(result);
+  result = convertPageMentions(result);
+  result = convertPageLinks(result);
+  result = convertUserMentions(result);
+  result = convertDateMentions(result);
+  result = removeUnknownBlocks(result);
+  result = convertNotionMath(result);
+  result = convertNotionTables(result);
+  result = convertColorSpans(result);
+  result = removeEmptyBlocks(result);
+  result = unescapePipes(result);
+  return result;
+}
+function obsidianToNotionEnhanced(obsidian) {
+  let result = obsidian;
+  result = convertTogglesToHtml(result);
+  result = convertObsidianCallouts(result);
+  return result;
+}
+function convertToggles(content) {
+  function replaceToggle(match) {
+    const m = /<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/s.exec(match);
+    if (!m) return match;
+    const title = m[1].trim();
+    let body = m[2].trim();
+    body = convertToggles(body);
+    const indented = body.split("\n").map((line) => line ? `  ${line}` : "").join("\n").trimEnd();
+    return `${TOGGLE_START2}
+- ${title}
+${indented}
+${TOGGLE_END2}`;
+  }
+  return content.replace(NOTION_TOGGLE_RE, replaceToggle);
+}
+function convertCallouts(content) {
+  return content.replace(NOTION_CALLOUT_RE, (_match, body) => {
+    const lines = body.trim().split("\n");
+    const firstLine = lines[0] ?? "";
+    const emojiMatch = /^([\p{Emoji}️‍]+)\s*(.*)/u.exec(firstLine);
+    const type = emojiMatch ? emojiToCalloutType(emojiMatch[1]) : "note";
+    const title = emojiMatch ? emojiMatch[2] : firstLine;
+    const rest = lines.slice(1).join("\n").trim();
+    const calloutTitle = title ? `> [!${type}] ${title}` : `> [!${type}]`;
+    const calloutBody = rest ? "\n" + rest.split("\n").map((line) => `> ${line}`).join("\n") : "";
+    return calloutTitle + calloutBody;
+  });
+}
+function convertPageMentions(content) {
+  return content.replace(NOTION_PAGE_MENTION_RE, (_match, _id, text) => {
+    const cleaned = text.trim();
+    return `[[${cleaned}]]`;
+  });
+}
+function convertUserMentions(content) {
+  return content.replace(NOTION_USER_MENTION_RE, (_match, name) => `@${name}`);
+}
+function convertDateMentions(content) {
+  return content.replace(NOTION_DATE_MENTION_RE, (_match, start, end) => {
+    return end ? `${start} \u2192 ${end}` : start;
+  });
+}
+function removeUnknownBlocks(content) {
+  return content.replace(NOTION_UNKNOWN_RE, "");
+}
+function convertTogglesToHtml(content) {
+  const startRe = new RegExp(escapeRegex3(TOGGLE_START2), "g");
+  const endRe = new RegExp(escapeRegex3(TOGGLE_END2), "g");
+  let result = content;
+  let safety = 0;
+  while (result.includes(TOGGLE_START2) && safety++ < 100) {
+    const startIdx = result.indexOf(TOGGLE_START2);
+    const endIdx = findMatchingEnd(result, startIdx + TOGGLE_START2.length);
+    if (endIdx === -1) break;
+    const inner = result.slice(startIdx + TOGGLE_START2.length, endIdx).trim();
+    const titleMatch = /^- (.+)$/m.exec(inner);
+    const title = titleMatch ? titleMatch[1] : "";
+    const body = inner.split("\n").slice(1).map((line) => line.replace(/^ {2}/, "")).join("\n").trim();
+    const html = `<details>
+<summary>${title}</summary>
+
+${body}
+
+</details>`;
+    result = result.slice(0, startIdx) + html + result.slice(endIdx + TOGGLE_END2.length);
+  }
+  result = result.replace(startRe, "").replace(endRe, "");
+  return result;
+}
+function findMatchingEnd(content, startFrom) {
+  let depth = 1;
+  let pos = startFrom;
+  while (pos < content.length && depth > 0) {
+    const nextStart = content.indexOf(TOGGLE_START2, pos);
+    const nextEnd = content.indexOf(TOGGLE_END2, pos);
+    if (nextEnd === -1) return -1;
+    if (nextStart !== -1 && nextStart < nextEnd) {
+      depth++;
+      pos = nextStart + TOGGLE_START2.length;
+    } else {
+      depth--;
+      if (depth === 0) return nextEnd;
+      pos = nextEnd + TOGGLE_END2.length;
+    }
+  }
+  return -1;
+}
+function convertObsidianCallouts(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const headerMatch = /^> \[!(\w+)\]([-+])?\s*(.*)/.exec(lines[i]);
+    if (headerMatch) {
+      const type = headerMatch[1];
+      const title = headerMatch[3];
+      const emoji = calloutTypeToEmoji(type) ?? "\u{1F4A1}";
+      const calloutTitle = title ? `${emoji} ${title}` : emoji;
+      const bodyLines = [];
+      i++;
+      while (i < lines.length && lines[i].startsWith("> ")) {
+        bodyLines.push(lines[i].slice(2));
+        i++;
+      }
+      result.push("::: callout");
+      result.push(calloutTitle);
+      if (bodyLines.length > 0) {
+        result.push(...bodyLines);
+      }
+      result.push(":::");
+    } else {
+      result.push(lines[i]);
+      i++;
+    }
+  }
+  return result.join("\n");
+}
+var EMOJI_TYPE_MAP2 = {
+  "\u{1F4A1}": "tip",
+  "\u2139\uFE0F": "info",
+  "\u26A0\uFE0F": "warning",
+  "\u{1F525}": "danger",
+  "\u2705": "success",
+  "\u274C": "failure",
+  "\u2753": "question",
+  "\u{1F4DD}": "note",
+  "\u{1F4CC}": "abstract",
+  "\u{1F41B}": "bug",
+  "\u{1F4AC}": "quote",
+  "\u{1F4CB}": "example"
+};
+var TYPE_EMOJI_MAP = Object.fromEntries(
+  Object.entries(EMOJI_TYPE_MAP2).map(([k, v]) => [v, k])
+);
+function emojiToCalloutType(emoji) {
+  return EMOJI_TYPE_MAP2[emoji] ?? "note";
+}
+function calloutTypeToEmoji(type) {
+  return TYPE_EMOJI_MAP[type.toLowerCase()];
+}
+function escapeRegex3(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var NOTION_PAGE_LINK_RE = /<page url="[^"]*">([\s\S]*?)<\/page>/g;
+var NOTION_COLOR_SPAN_RE = /<span color="([^"]+)">([\s\S]*?)<\/span>/g;
+var NOTION_EMPTY_BLOCK_RE = /^<empty-block\/>\n?/gm;
+function convertPageLinks(content) {
+  return content.replace(NOTION_PAGE_LINK_RE, (_match, text) => {
+    const cleaned = text.replace(/\*\*/g, "").trim();
+    return `[[${cleaned}]]`;
+  });
+}
+function convertColorSpans(content) {
+  return content.replace(NOTION_COLOR_SPAN_RE, (_match, _color, text) => text);
+}
+function removeEmptyBlocks(content) {
+  return content.replace(NOTION_EMPTY_BLOCK_RE, "\n");
+}
+var NOTION_INLINE_MATH_RE = /\$`([^`]+)`\$/g;
+var NOTION_BLOCK_MATH_RE = /\$\$\n```\n([\s\S]*?)\n```\n\$\$/g;
+function convertNotionMath(content) {
+  let result = content.replace(NOTION_BLOCK_MATH_RE, (_match, eq) => {
+    return `$$
+${eq.trim()}
+$$`;
+  });
+  result = result.replace(NOTION_INLINE_MATH_RE, (_match, eq) => `$${eq}$`);
+  return result;
+}
+var NOTION_TABLE_RE = /<table[^>]*>([\s\S]*?)<\/table>/g;
+var TABLE_ROW_RE = /<tr>([\s\S]*?)<\/tr>/g;
+var TABLE_CELL_RE = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/g;
+function convertNotionTables(content) {
+  return content.replace(NOTION_TABLE_RE, (_match, tableBody) => {
+    const rows = [];
+    let rowMatch;
+    const rowRe = new RegExp(TABLE_ROW_RE.source, TABLE_ROW_RE.flags);
+    while ((rowMatch = rowRe.exec(tableBody)) !== null) {
+      const cells = [];
+      let cellMatch;
+      const cellRe = new RegExp(TABLE_CELL_RE.source, TABLE_CELL_RE.flags);
+      while ((cellMatch = cellRe.exec(rowMatch[1])) !== null) {
+        cells.push(cellMatch[1].trim());
+      }
+      rows.push(cells);
+    }
+    if (rows.length === 0) return _match;
+    const colCount = Math.max(...rows.map((r) => r.length));
+    const lines = [];
+    for (let i = 0; i < rows.length; i++) {
+      const padded = rows[i];
+      while (padded.length < colCount) padded.push("");
+      lines.push(`| ${padded.join(" | ")} |`);
+      if (i === 0) {
+        lines.push(`| ${padded.map(() => "---").join(" | ")} |`);
+      }
+    }
+    return lines.join("\n");
+  });
+}
+function unescapePipes(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inTable = false;
+  for (const line of lines) {
+    if (/^\|.*\|$/.test(line.trim()) || /^\|[\s-|]+\|$/.test(line.trim())) {
+      inTable = true;
+      result.push(line);
+    } else {
+      if (inTable && line.trim() === "") {
+        inTable = false;
+      } else if (!/^\|/.test(line.trim())) {
+        inTable = false;
+      }
+      result.push(inTable ? line : line.replace(/\\\|/g, "|"));
+    }
+  }
+  return result.join("\n");
+}
+
 // src/sync/orchestrator.ts
 var SyncOrchestrator = class {
   constructor(config, stateDb, notionClient, vaultFs) {
@@ -2470,9 +2997,11 @@ var SyncOrchestrator = class {
     this.notionClient = notionClient;
     this.vaultFs = vaultFs;
     this.changeDetector = new ChangeDetector(stateDb);
-    this.pipeline = createDefaultPipeline();
+    this.pipeline = createDefaultPipeline({
+      wikilinkResolver: (text) => stateDb.resolveWikilink(text)
+    });
     this.blockConverter = new BlockConverter();
-    this.imageHandler = new ImageHandler(vaultFs, config.paths.attachments);
+    this.imageHandler = new ImageHandler(vaultFs, config.paths.attachments, notionClient);
     this.propertyMapper = new PropertyMapper();
     this.blockConverter.initNotionToMd(this.notionClient.getInternalClient());
   }
@@ -2488,16 +3017,29 @@ var SyncOrchestrator = class {
   dbSchemaLoaded = false;
   async push(options) {
     const startTime = Date.now();
+    if (this.config.sync.direction === "pull") {
+      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);
     const conflictPaths = new Set(this.stateDb.getByStatus("conflict").map((r) => r.obsidianPath));
-    const nonConflict = changes.filter((c) => !conflictPaths.has(c.path));
-    const filtered = options?.paths ? nonConflict.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : nonConflict;
+    const eligible = options?.force ? changes : changes.filter((c) => !conflictPaths.has(c.path));
+    const filtered = options?.paths ? eligible.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : eligible;
     if (filtered.length === 0) {
       return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
     }
     if (options?.dryRun) {
-      return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
+      const dryCreated = filtered.filter((c) => c.type === "created").length;
+      const dryUpdated = filtered.filter((c) => c.type === "modified" || c.type === "moved").length;
+      const dryDeleted = filtered.filter((c) => c.type === "deleted").length;
+      return {
+        created: dryCreated,
+        updated: dryUpdated,
+        deleted: dryDeleted,
+        failed: [],
+        duration: Date.now() - startTime
+      };
     }
     this.stateDb.setMeta("push_in_progress", "true");
     const folderPaths = /* @__PURE__ */ new Set();
@@ -2559,6 +3101,19 @@ var SyncOrchestrator = class {
   }
   async pull(options) {
     const startTime = Date.now();
+    const emptyResult = {
+      created: 0,
+      updated: 0,
+      deleted: 0,
+      conflicts: [],
+      writtenPaths: [],
+      failed: [],
+      duration: Date.now() - startTime
+    };
+    if (this.config.sync.direction === "push") {
+      return emptyResult;
+    }
+    this.cleanupInterruptedSync();
     let created = 0;
     let updated = 0;
     let deleted = 0;
@@ -2570,11 +3125,17 @@ var SyncOrchestrator = class {
       const record = this.stateDb.getByNotionId(c.pageId);
       return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
     }) : remoteChanges;
-    if (options?.dryRun || filtered.length === 0) {
+    if (filtered.length === 0) {
+      return emptyResult;
+    }
+    if (options?.dryRun) {
+      const dryCreated = filtered.filter((c) => c.type === "created").length;
+      const dryUpdated = filtered.filter((c) => c.type === "modified").length;
+      const dryDeleted = filtered.filter((c) => c.type === "deleted").length;
       return {
-        created: 0,
-        updated: 0,
-        deleted: 0,
+        created: dryCreated,
+        updated: dryUpdated,
+        deleted: dryDeleted,
         conflicts: [],
         writtenPaths: [],
         failed: [],
@@ -2729,7 +3290,6 @@ var SyncOrchestrator = class {
       filePath: path,
       parentMode: this.config.notion.parentMode
     });
-    const blocks = this.blockConverter.markdownToNotionBlocks(conversionResult.content);
     let effectiveParentId = parentId;
     let effectiveParentType = "page";
     let effectiveProperties = conversionResult.properties;
@@ -2742,15 +3302,14 @@ var SyncOrchestrator = class {
         title
       );
     }
-    const page = await this.notionClient.createPage({
-      parentId: effectiveParentId,
-      parentType: effectiveParentType,
+    const page = await this.pushCreatePage(
+      effectiveParentId,
+      effectiveParentType,
       title,
-      properties: effectiveProperties
-    });
-    if (blocks.length > 0) {
-      await this.notionClient.appendChildren(page.id, blocks);
-    }
+      conversionResult.content,
+      effectiveProperties
+    );
+    await this.imageHandler.uploadAndAppendImages(page.id, conversionResult.images);
     const hash = computeHash(content);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
@@ -2765,11 +3324,12 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(content, "utf-8")
       });
+      const aliases = extractAliases(conversionResult.properties);
       this.stateDb.upsertWikilink({
         obsidianPath: path,
         notionPageId: page.id,
         title,
-        aliases: []
+        aliases
       });
       this.stateDb.storePreserveMarkers(path, conversionResult.preserveMarkers);
     });
@@ -2790,28 +3350,32 @@ var SyncOrchestrator = class {
       filePath: path,
       parentMode: this.config.notion.parentMode
     });
-    const blocks = this.blockConverter.markdownToNotionBlocks(conversionResult.content);
-    const existingBlocks = await this.notionClient.fetchAllChildren(record.notionPageId);
-    if (blocks.length > 0) {
-      await this.notionClient.appendChildren(record.notionPageId, blocks);
-    }
-    for (const block of existingBlocks) {
-      await this.notionClient.deleteBlock(block.id);
-    }
+    await this.pushUpdatePage(record.notionPageId, conversionResult.content);
+    await this.imageHandler.uploadAndAppendImages(record.notionPageId, conversionResult.images);
     let propsToUpdate = conversionResult.properties;
     if (this.isDatabaseMode && propsToUpdate && Object.keys(propsToUpdate).length > 0) {
       await this.ensureDbSchema();
-      const title = extractTitle(path);
-      propsToUpdate = this.propertyMapper.toNotionProperties(propsToUpdate, title);
+      const title2 = extractTitle(path);
+      propsToUpdate = this.propertyMapper.toNotionProperties(propsToUpdate, title2);
     }
     if (propsToUpdate && Object.keys(propsToUpdate).length > 0) {
       await this.notionClient.updatePageProperties(record.notionPageId, propsToUpdate);
     }
+    const updatedPage = await this.notionClient.getPage(record.notionPageId);
     const hash = computeHash(content);
+    const title = extractTitle(path);
+    const aliases = extractAliases(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.storePreserveMarkers(path, conversionResult.preserveMarkers);
+      this.stateDb.upsertWikilink({
+        obsidianPath: path,
+        notionPageId: record.notionPageId,
+        title,
+        aliases
+      });
     });
   }
   async pushDelete(path) {
@@ -2819,8 +3383,10 @@ var SyncOrchestrator = class {
     if (!record?.notionPageId) return;
     if (this.config.sync.deleteSync) {
       await this.notionClient.archivePage(record.notionPageId);
+      this.stateDb.delete(record.id);
+    } else {
+      this.stateDb.updateStatus(record.id, "pending");
     }
-    this.stateDb.delete(record.id);
   }
   async detectRemoteChanges() {
     const changes = [];
@@ -2885,24 +3451,25 @@ var SyncOrchestrator = class {
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
-    const children = await this.notionClient.listChildren(pageId, { pageSize: 1 });
-    const hasChildPages = children.results.some((b) => "type" in b && b.type === "child_page");
-    const markdown = await this.blockConverter.notionBlocksToMarkdown(pageId);
+    const allChildren = await this.notionClient.fetchAllChildren(pageId);
+    const hasChildPages = allChildren.some((b) => "type" in b && b.type === "child_page");
+    const markdown = await this.fetchPageMarkdown(pageId);
     const hasContent = markdown.trim().length > 0;
     let filePath;
     let fileType;
     if (hasChildPages && hasContent) {
       const folderPath = parentPath ? `${parentPath}/${safeName}` : safeName;
-      filePath = `${folderPath}/${safeName}.md`;
+      filePath = await this.resolveUniqueFilePath(`${folderPath}/${safeName}.md`);
       fileType = "folder-note";
       await this.vaultFs.ensureFolder(folderPath);
     } else if (hasChildPages && !hasContent) {
       const folderPath = parentPath ? `${parentPath}/${safeName}` : safeName;
-      filePath = `${folderPath}/${safeName}.md`;
+      filePath = await this.resolveUniqueFilePath(`${folderPath}/${safeName}.md`);
       fileType = "folder-only";
       await this.vaultFs.ensureFolder(folderPath);
     } else {
-      filePath = parentPath ? `${parentPath}/${safeName}.md` : `${safeName}.md`;
+      const basePath = parentPath ? `${parentPath}/${safeName}.md` : `${safeName}.md`;
+      filePath = await this.resolveUniqueFilePath(basePath);
       fileType = "file";
     }
     let properties;
@@ -2914,6 +3481,7 @@ var SyncOrchestrator = class {
     } else {
       properties = this.notionClient.extractProperties(page);
     }
+    properties.title = title;
     let processedMarkdown = markdown;
     if (this.config.conversion.imageDownload === "immediate") {
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
@@ -2944,11 +3512,12 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(finalContent, "utf-8")
       });
+      const aliases = extractAliases(properties);
       this.stateDb.upsertWikilink({
         obsidianPath: filePath,
         notionPageId: pageId,
         title,
-        aliases: []
+        aliases
       });
     });
     return filePath;
@@ -2957,7 +3526,8 @@ var SyncOrchestrator = class {
     const record = this.stateDb.getByNotionId(change.pageId);
     if (!record) return {};
     const page = await this.notionClient.getPage(change.pageId);
-    let markdown = await this.blockConverter.notionBlocksToMarkdown(change.pageId);
+    let markdown = await this.fetchPageMarkdown(change.pageId);
+    const title = this.notionClient.extractTitle(page);
     let properties;
     if (this.isDatabaseMode) {
       await this.ensureDbSchema();
@@ -2967,8 +3537,8 @@ var SyncOrchestrator = class {
     } else {
       properties = this.notionClient.extractProperties(page);
     }
+    properties.title = title;
     if (this.config.conversion.imageDownload === "immediate") {
-      const title = this.notionClient.extractTitle(page);
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
       markdown = imageResult.content;
     }
@@ -2992,21 +3562,26 @@ var SyncOrchestrator = class {
     const localHash = computeHash(localContent);
     const localModified = localHash !== record.contentHash;
     if (localModified) {
-      const conflict = {
-        syncRecord: record,
-        localChange: {
-          path: record.obsidianPath,
-          type: "modified",
-          currentHash: localHash,
-          previousHash: record.contentHash
-        },
-        remoteChange: change,
-        baseContent: record.baseSnapshot?.toString("utf-8") ?? null,
-        localContent,
-        remoteContent
-      };
-      this.stateDb.updateStatus(record.id, "conflict");
-      return { conflict };
+      const strategy = this.config.sync.conflictStrategy;
+      if (strategy === "remote-first") ; else if (strategy === "local-first") {
+        return { path: record.obsidianPath };
+      } else {
+        const conflict = {
+          syncRecord: record,
+          localChange: {
+            path: record.obsidianPath,
+            type: "modified",
+            currentHash: localHash,
+            previousHash: record.contentHash
+          },
+          remoteChange: change,
+          baseContent: record.baseSnapshot?.toString("utf-8") ?? null,
+          localContent,
+          remoteContent
+        };
+        this.stateDb.updateStatus(record.id, "conflict");
+        return { conflict };
+      }
     }
     await this.vaultFs.writeFile(record.obsidianPath, remoteContent);
     const newHash = computeHash(remoteContent);
@@ -3039,6 +3614,22 @@ var SyncOrchestrator = class {
   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"
+      });
+      return;
+    }
     const parts = folderPath.split("/");
     const folderName = parts[parts.length - 1];
     let parentId = this.config.notion.rootPageId;
@@ -3099,23 +3690,118 @@ var SyncOrchestrator = class {
     try {
       const parentPage = await this.notionClient.getPage(parentId);
       const parentTitle = this.notionClient.extractTitle(parentPage);
-      return sanitizeFileName(parentTitle);
+      const grandparentPath = await this.resolveParentPath(parentPage);
+      const safeName = sanitizeFileName(parentTitle);
+      return grandparentPath ? `${grandparentPath}/${safeName}` : safeName;
     } catch {
       return "";
     }
   }
+  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 blocks = this.blockConverter.markdownToNotionBlocks(markdownContent);
+    const page = await this.notionClient.createPage({
+      parentId,
+      parentType,
+      title,
+      properties
+    });
+    if (blocks.length > 0) {
+      await this.notionClient.appendChildren(page.id, blocks);
+    }
+    return page;
+  }
+  async pushUpdatePage(pageId, markdownContent) {
+    if (this.config.conversion.preferMarkdownApi !== false) {
+      try {
+        const enhanced = obsidianToNotionEnhanced(markdownContent);
+        await this.notionClient.replacePageMarkdown(pageId, enhanced);
+        return;
+      } catch {
+      }
+    }
+    const blocks = this.blockConverter.markdownToNotionBlocks(markdownContent);
+    const existingBlocks = await this.notionClient.fetchAllChildren(pageId);
+    if (blocks.length > 0) {
+      await this.notionClient.appendChildren(pageId, blocks);
+    }
+    const deleteSema = new Sema(this.config.advanced.concurrency);
+    await Promise.all(
+      existingBlocks.map(async (block) => {
+        await deleteSema.acquire();
+        try {
+          await this.notionClient.deleteBlock(block.id);
+        } finally {
+          deleteSema.release();
+        }
+      })
+    );
+  }
+  async fetchPageMarkdown(pageId) {
+    if (this.config.conversion.preferMarkdownApi !== false) {
+      try {
+        const result = await this.notionClient.getPageMarkdown(pageId);
+        return notionEnhancedToObsidian(result.markdown);
+      } catch {
+      }
+    }
+    return this.blockConverter.notionBlocksToMarkdown(pageId);
+  }
   extractParentId(page) {
     const parent = page.parent;
     if (parent.type === "page_id") return parent.page_id ?? null;
     if (parent.type === "database_id") return parent.database_id ?? null;
     return null;
   }
+  cleanupInterruptedSync() {
+    const pushInProgress = this.stateDb.getMeta("push_in_progress");
+    const pullInProgress = this.stateDb.getMeta("pull_in_progress");
+    if (pushInProgress === "true") {
+      getLogger().warn("[Im-Nobsidian] \uC774\uC804 push\uAC00 \uBE44\uC815\uC0C1 \uC885\uB8CC\uB428 \u2014 \uD50C\uB798\uADF8 \uC815\uB9AC");
+      this.stateDb.setMeta("push_in_progress", "");
+    }
+    if (pullInProgress === "true") {
+      getLogger().warn("[Im-Nobsidian] \uC774\uC804 pull\uC774 \uBE44\uC815\uC0C1 \uC885\uB8CC\uB428 \u2014 \uD50C\uB798\uADF8 \uC815\uB9AC");
+      this.stateDb.setMeta("pull_in_progress", "");
+    }
+  }
+  async resolveUniqueFilePath(basePath) {
+    if (!await this.vaultFs.exists(basePath)) return basePath;
+    const dir = basePath.lastIndexOf("/") >= 0 ? basePath.slice(0, basePath.lastIndexOf("/")) : "";
+    const ext = ".md";
+    const name = basePath.slice(dir ? dir.length + 1 : 0, -ext.length);
+    for (let i = 1; i <= 99; i++) {
+      const candidate = dir ? `${dir}/${name} (${i})${ext}` : `${name} (${i})${ext}`;
+      if (!await this.vaultFs.exists(candidate)) return candidate;
+    }
+    return basePath;
+  }
 };
 function extractTitle(filePath) {
   const parts = filePath.split("/");
   const filename = parts[parts.length - 1] ?? "";
   return filename.replace(/\.md$/, "");
 }
+function extractAliases(properties) {
+  const raw = properties.aliases ?? properties.alias;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
+  if (typeof raw === "string")
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return [];
+}
 var NodeVaultFS = class {
   constructor(rootPath, pathConfig) {
     this.rootPath = rootPath;
@@ -3140,6 +3826,10 @@ var NodeVaultFS = class {
     const fullPath = join(this.rootPath, path);
     return readFile(fullPath, "utf-8");
   }
+  async readBinary(path) {
+    const fullPath = join(this.rootPath, path);
+    return readFile(fullPath);
+  }
   async writeFile(path, content) {
     const fullPath = join(this.rootPath, path);
     await mkdir(dirname(fullPath), { recursive: true });