[ENG-1450] Update wikilink (#807)

* wip

* make sure the import has filePath now

* address PR comments

* make sure it rewrites filePath

* cleanup log

* prettier

* Update apps/obsidian/src/utils/importNodes.ts

Co-authored-by: devin-ai-integration[bot] <158243242+devin-ai-integration[bot]@users.noreply.github.com>

* address the [markdown link]()

* Factor out common code. Also avoid adding spurious file extension. Also disguise relative links.

* Devin correction; and decode linkPath

* make sure to use decodeURIComponents instead

* address PR comments

* address PR comment

---------

Co-authored-by: devin-ai-integration[bot] <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Marc-Antoine Parent <maparent@acm.org>

Author: 3 people

apps/obsidian/src/utils/importNodes.ts

@@ -483,11 +483,7 @@ const updateMarkdownAssetLinks = ({
   app: App;
   originalNodePath?: string;
 }): string => {
-  if (oldPathToNewPath.size === 0) {
-    return content;
-  }
-
-  // Create a set of all new paths for quick lookup (used by findImportedAssetFile)
+  // Create a set of all new paths for quick lookup (used by findImportedAssetFile when pathMapping has entries)
   const newPaths = new Set(oldPathToNewPath.values());
 
   let updatedContent = content;
@@ -496,6 +492,13 @@ const updateMarkdownAssetLinks = ({
     ? targetFile.path.replace(/\/[^/]*$/, "")
     : "";
 
+  // When the note is under import/{spaceName}/, only treat wiki links as resolved if the target is in this folder (not some other vault file).
+  const pathParts = targetFile.path.split("/");
+  const importFolder =
+    pathParts[0] === "import" && pathParts.length >= 2
+      ? pathParts.slice(0, 2).join("/")
+      : null;
+
   /** Path of targetFile relative to the current note, for use in links. Obsidian resolves relative links from the note's directory. */
   const getRelativeLinkPath = (assetPath: string): string => {
     const noteParts = noteDir ? noteDir.split("/").filter(Boolean) : [];
@@ -599,48 +602,100 @@ const updateMarkdownAssetLinks = ({
     return null;
   };
 
+  const processLink = (linkPath: string): string => {
+    // Skip external URLs
+    if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) {
+      return linkPath;
+    }
+
+    // First, try to find if this link resolves to one of our imported assets
+    const importedAssetFile = findImportedAssetFile(linkPath);
+    if (importedAssetFile) {
+      return getRelativeLinkPath(importedAssetFile.path);
+    }
+
+    // Direct lookup from pathMapping (record built when we downloaded each asset)
+    const newPath = getNewPathForLink(linkPath);
+    if (newPath) {
+      const newFile = app.metadataCache.getFirstLinkpathDest(
+        newPath,
+        targetFile.path,
+      );
+      if (newFile) {
+        return getRelativeLinkPath(newFile.path);
+      }
+    }
+
+    // Only resolve to files under import/{spaceName}/ so we don't point at the wrong vault's files
+    const resolvedFile = app.metadataCache.getFirstLinkpathDest(
+      linkPath,
+      targetFile.path,
+    );
+    const isInImportFolder =
+      importFolder &&
+      resolvedFile &&
+      resolvedFile.path.startsWith(importFolder + "/");
+    if (isInImportFolder && resolvedFile) {
+      return getRelativeLinkPath(resolvedFile.path);
+    }
+
+    // Unresolved (dead) link from another vault: rewrite so that when the user creates the file from this link, it is created under import/{vaultName}/ in the same relative position as in the source vault
+    if (importFolder && originalNodePath && !resolvedFile) {
+      // Vault-relative link (e.g. "Discourse Nodes/EVD - no relation testing") -> use as-is. Path-from-current-file (e.g. "EVD - no relation testing") -> resolve relative to source note dir
+      const canonicalSourcePath =
+        linkPath.includes("/") &&
+        !linkPath.startsWith(".") &&
+        !linkPath.startsWith("/")
+          ? normalizePathForLookup(linkPath)
+          : (getCanonicalFromOriginalNote(linkPath) ??
+            normalizePathForLookup(linkPath));
+      return `${importFolder}/${canonicalSourcePath}`;
+    }
+
+    return linkPath;
+  };
+
   // Match wiki links: [[path]] or [[path|alias]]
   const wikiLinkRegex = /\[\[([^\]]+)\]\]/g;
   updatedContent = updatedContent.replace(
     wikiLinkRegex,
-    (match, linkContent) => {
+    (match, linkContent: string) => {
       // Extract path and optional alias
       const [linkPath, alias] = linkContent
         .split("|")
         .map((s: string) => s.trim());
-
-      // Skip external URLs
-      if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) {
-        return match;
-      }
-
-      // First, try to find if this link resolves to one of our imported assets
-      const importedAssetFile = findImportedAssetFile(linkPath);
-      if (importedAssetFile) {
-        const linkText = getRelativeLinkPath(importedAssetFile.path);
-        if (alias) {
-          return `[[${linkText}|${alias}]]`;
-        }
-        return `[[${linkText}]]`;
+      if (!linkPath) return match;
+      let processedPath = processLink(linkPath);
+      if (processedPath.endsWith(".md") && !linkPath.endsWith(".md"))
+        processedPath = processedPath.substring(0, processedPath.length - 3);
+      if (alias) {
+        return `[[${processedPath}|${alias}]]`;
       }
+      return `[[${processedPath}|${linkPath}]]`;
+    },
+  );
 
-      // Direct lookup from pathMapping (record built when we downloaded each asset)
-      const newPath = getNewPathForLink(linkPath);
-      if (newPath) {
-        const newFile = app.metadataCache.getFirstLinkpathDest(
-          newPath,
-          targetFile.path,
-        );
-        if (newFile) {
-          const linkText = getRelativeLinkPath(newFile.path);
-          if (alias) {
-            return `[[${linkText}|${alias}]]`;
+  // Match markdown links (non-image): [text](path) — internal paths resolved like wikilinks, href kept URL-encoded
+  const markdownLinkRegex = /(?<!!)\[([^\]]*)\]\(([^)]+)\)/g;
+  updatedContent = updatedContent.replace(
+    markdownLinkRegex,
+    (match, linkText: string, linkPath: string) => {
+      if (!linkPath) return match;
+      linkPath = linkPath
+        .split("/")
+        .map((segment) => {
+          try {
+            return decodeURIComponent(segment);
+          } catch {
+            return segment;
           }
-          return `[[${linkText}]]`;
-        }
+        })
+        .join("/");
+      if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) {
+        return match;
       }
-
-      return match;
+      const processedPath = encodePathForMarkdownLink(processLink(linkPath));
+      return `[${linkText}](${processedPath})`;
     },
   );
 
@@ -911,6 +966,15 @@ const sanitizeFileName = (fileName: string): string => {
     .trim();
 };
 
+/** Sanitize each path segment for use under import folder (preserves source vault folder structure). */
+const sanitizePathForImport = (path: string): string => {
+  return path
+    .split("/")
+    .map((segment) => sanitizeFileName(segment))
+    .filter(Boolean)
+    .join("/");
+};
+
 type ParsedFrontmatter = {
   nodeTypeId?: string;
   nodeInstanceId?: string;
@@ -1210,11 +1274,13 @@ export const importSelectedNodes = async ({
           content,
           createdAt: contentCreatedAt,
           modifiedAt: contentModifiedAt,
-          filePath,
+          filePath: contentFilePath,
         } = nodeContent;
         const createdAt = node.createdAt ?? contentCreatedAt;
         const modifiedAt = node.modifiedAt ?? contentModifiedAt;
-        const originalNodePath: string | undefined = node.filePath;
+        // Use source vault path from Content direct variant metadata for wikilink rewriting and asset placement
+        const originalNodePath: string | undefined =
+          contentFilePath ?? node.filePath;
 
         // Sanitize file name
         const sanitizedFileName = sanitizeFileName(fileName);
@@ -1224,14 +1290,20 @@ export const importSelectedNodes = async ({
           // Update existing file - use its current path
           finalFilePath = existingFile.path;
         } else {
-          // Create new file in the import folder
-          finalFilePath = `${importFolderPath}/${sanitizedFileName}.md`;
-
-          // Check if file path already exists (edge case: same title but different nodeInstanceId)
-          let counter = 1;
-          while (await plugin.app.vault.adapter.exists(finalFilePath)) {
-            finalFilePath = `${importFolderPath}/${sanitizedFileName} (${counter}).md`;
-            counter++;
+          // Preserve source vault folder structure under import/{vaultName} when we have filePath from Content
+          const pathUnderImport =
+            contentFilePath && contentFilePath.includes("/")
+              ? sanitizePathForImport(contentFilePath)
+              : `${sanitizedFileName}.md`;
+          finalFilePath = `${importFolderPath}/${pathUnderImport}`;
+
+          // Ensure all parent folders exist (e.g. import/VaultName/Discourse Nodes/SubFolder)
+          const dirParts = finalFilePath.split("/");
+          for (let i = 1; i < dirParts.length - 1; i++) {
+            const folderPath = dirParts.slice(0, i + 1).join("/");
+            if (!(await plugin.app.vault.adapter.exists(folderPath))) {
+              await plugin.app.vault.createFolder(folderPath);
+            }
           }
         }
 
@@ -1243,7 +1315,7 @@ export const importSelectedNodes = async ({
           sourceSpaceId: spaceId,
           sourceSpaceUri: spaceUri,
           rawContent: content,
-          originalFilePath: filePath,
+          originalFilePath: contentFilePath,
           filePath: finalFilePath,
           importedCreatedAt: createdAt,
           importedModifiedAt: modifiedAt,
@@ -1274,30 +1346,31 @@ export const importSelectedNodes = async ({
           originalNodePath,
         });
 
-        // Update markdown content with new asset paths if assets were imported
-        if (assetImportResult.pathMapping.size > 0) {
-          const currentContent = await plugin.app.vault.read(processedFile);
-          const updatedContent = updateMarkdownAssetLinks({
-            content: currentContent,
-            oldPathToNewPath: assetImportResult.pathMapping,
-            targetFile: processedFile,
-            app: plugin.app,
-            originalNodePath,
-          });
-
-          // Only update if content changed
-          if (updatedContent !== currentContent) {
-            await plugin.app.vault.process(processedFile, () => updatedContent);
-          }
+        // Update markdown content: rewrite asset paths from pathMapping and normalize all wiki links to relative paths
+        const currentContent = await plugin.app.vault.read(processedFile);
+        const updatedContent = updateMarkdownAssetLinks({
+          content: currentContent,
+          oldPathToNewPath: assetImportResult.pathMapping,
+          targetFile: processedFile,
+          app: plugin.app,
+          originalNodePath,
+        });
+
+        // Only update if content changed
+        if (updatedContent !== currentContent) {
+          await plugin.app.vault.process(processedFile, () => updatedContent);
         }
 
         // If title changed and file exists, rename it to match the new title
         if (existingFile && processedFile.basename !== sanitizedFileName) {
-          const newPath = `${importFolderPath}/${sanitizedFileName}.md`;
+          const currentDir = processedFile.path.includes("/")
+            ? processedFile.path.replace(/\/[^/]*$/, "")
+            : importFolderPath;
+          const newPath = `${currentDir}/${sanitizedFileName}.md`;
           let targetPath = newPath;
           let counter = 1;
           while (await plugin.app.vault.adapter.exists(targetPath)) {
-            targetPath = `${importFolderPath}/${sanitizedFileName} (${counter}).md`;
+            targetPath = `${currentDir}/${sanitizedFileName} (${counter}).md`;
             counter++;
           }
           await plugin.app.fileManager.renameFile(processedFile, targetPath);
@@ -1442,3 +1515,11 @@ export const refreshAllImportedFiles = async (
 
   return { success: successCount, failed: failedCount, errors };
 };
+
+const encodePathForMarkdownLink = (linkPath: string): string => {
+  // Input is already decoded; encode each segment (spaces → %20) but keep / as separator
+  return linkPath
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+};