fix: migrate FileUtils to VFS (#6866)

* fix: migrate FileUtils to VFS

I replicated the original behavior, for example, writeFile should automatically create dirs + overwrite the file (if exists), readText normalizes line endings + limits the output to 10k chars, etc. All those details should be covered by unit test.

Also, I removed some usages of UriUtils because if we treat "file URIs" as URLs, we can use refreshAndFindFileByUrl. It works, but we should keep that in mind.

### Extra: Manual testing

(I did it myself on top of the unit tests, but I’m posting the instructions here in case someone wants to reproduce it)

* writeFile - run Continue in agentic mode and ask smth like: "create scss/test.scss"
* listDir (+ getFileStats) - ask: "list files in project root"
* openFile/showFile - edit a rule using the toolbar (pen icon)
* fileExists - is invoked on startup multiple times
* readFile - is invoked on startup multiple times (put some files into .continue/*)

* fix: remove params in FileUtils

* fix: read from documents if possible

Author: exigow

extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IntelliJIde.kt

@@ -47,7 +47,7 @@ class IntelliJIDE(
     ) : IDE {
 
     private val gitService = GitService(project, continuePluginService)
-    private val fileUtils = FileUtils()
+    private val fileUtils = FileUtils(project)
     private val ripgrep: String = getRipgrepPath()
 
     init {
@@ -183,7 +183,9 @@ class IntelliJIDE(
         fileUtils.fileExists(filepath)
 
     override suspend fun writeFile(path: String, contents: String) =
-        fileUtils.writeFile(path, contents)
+        withContext(Dispatchers.EDT) {
+            fileUtils.writeFile(path, contents)
+        }
 
     override suspend fun showVirtualFile(title: String, contents: String) {
         val virtualFile = LightVirtualFile(title, contents)
@@ -196,20 +198,8 @@ class IntelliJIDE(
         return getContinueGlobalPath()
     }
 
-    override suspend fun openFile(path: String) {
-        // Convert URI path to absolute file path
-        val filePath = UriUtils.uriToFile(path).absolutePath
-        // Find the file using the absolute path
-        val file = withContext(Dispatchers.IO) {
-            LocalFileSystem.getInstance().refreshAndFindFileByPath(filePath)
-        }
-
-        file?.let {
-            ApplicationManager.getApplication().invokeLater {
-                FileEditorManager.getInstance(project).openFile(it, true)
-            }
-        }
-    }
+    override suspend fun openFile(path: String) =
+        fileUtils.openFile(path)
 
     override suspend fun openUrl(url: String) {
         withContext(Dispatchers.IO) {
@@ -278,18 +268,10 @@ class IntelliJIDE(
         }
     }
 
-    override suspend fun saveFile(filepath: String) {
-        ApplicationManager.getApplication().invokeLater {
-            val file =
-                LocalFileSystem.getInstance().findFileByPath(UriUtils.parseUri(filepath).path) ?: return@invokeLater
-            val fileDocumentManager = FileDocumentManager.getInstance()
-            val document = fileDocumentManager.getDocument(file)
-
-            document?.let {
-                fileDocumentManager.saveDocument(it)
-            }
+    override suspend fun saveFile(filepath: String) =
+        withContext(Dispatchers.EDT) {
+            fileUtils.saveFile(filepath)
         }
-    }
 
     override suspend fun readFile(filepath: String): String =
         fileUtils.readFile(filepath)
@@ -604,11 +586,8 @@ class IntelliJIDE(
     override suspend fun listDir(dir: String): List<List<Any>> =
         fileUtils.listDir(dir)
 
-    override suspend fun getFileStats(files: List<String>): Map<String, FileStats> {
-        return files.associateWith { file ->
-            FileStats(UriUtils.uriToFile(file).lastModified(), UriUtils.uriToFile(file).length())
-        }
-    }
+    override suspend fun getFileStats(files: List<String>): Map<String, FileStats> =
+        fileUtils.getFileStats(files)
 
     override suspend fun gotoDefinition(location: Location): List<RangeInFile> {
         throw NotImplementedError("gotoDefinition not implemented yet")

extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/file/FileUtils.kt

@@ -1,69 +1,110 @@
 package com.github.continuedev.continueintellijextension.`continue`.file
 
+import com.github.continuedev.continueintellijextension.FileStats
 import com.github.continuedev.continueintellijextension.FileType
-import com.github.continuedev.continueintellijextension.`continue`.UriUtils
-import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.runReadAction
+import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.fileEditor.FileDocumentManager
-import com.intellij.openapi.vfs.LocalFileSystem
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import java.io.FileInputStream
-import java.nio.charset.Charset
+import com.intellij.openapi.fileEditor.FileEditorManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.TextRange
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.openapi.vfs.VfsUtilCore
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
+import kotlin.math.min
 
-class FileUtils {
-    // todo: use VFS (it's moved from IntellijIde)
 
-    fun fileExists(uri: String): Boolean {
-        val file = UriUtils.uriToFile(uri)
-        return file.exists()
+class FileUtils(
+    private val project: Project,
+) {
+    fun fileExists(fileUri: String): Boolean =
+        findFile(fileUri) != null
+
+    fun writeFile(fileUri: String, content: String) {
+        val path = VfsUtilCore.urlToPath(fileUri)
+        val pathDirectory = VfsUtil.getParentDir(path)
+            ?: return
+        val vfsDirectory = VfsUtil.createDirectories(pathDirectory)
+        val pathFilename = VfsUtil.extractFileName(path)
+            ?: return
+        runWriteAction {
+            val newFile = vfsDirectory.createChildData(this, pathFilename)
+            VfsUtil.saveText(newFile, content)
+        }
     }
 
-    fun writeFile(uri: String, contents: String) {
-        val file = UriUtils.uriToFile(uri)
-        file.parentFile?.mkdirs()
-        file.writeText(contents)
+    fun listDir(fileUri: String): List<List<Any>> {
+        val found = findFile(fileUri)
+            ?: return emptyList()
+        if (!found.isDirectory)
+            return emptyList()
+        return found.children.map { file ->
+            val fileType = if (file.isDirectory)
+                FileType.DIRECTORY.value
+            else
+                FileType.FILE.value
+            listOf(file.name, fileType)
+        }
     }
 
-    fun listDir(dir: String): List<List<Any>> {
-        val files = UriUtils.uriToFile(dir).listFiles()?.map {
-            listOf(it.name, if (it.isDirectory) FileType.DIRECTORY.value else FileType.FILE.value)
-        } ?: emptyList()
+    fun readFile(fileUri: String, maxLength: Int = 100_000): String {
+        val found = findFile(fileUri)
+            ?: return ""
+        val text = runReadAction {
+            // note: document (if exists) is more up-to-date than VFS
+            readDocument(found, maxLength) ?: VfsUtil.loadText(found, maxLength)
+        }
+        return normalizeLineEndings(text)
+    }
 
-        return files
+    fun openFile(fileUri: String) {
+        val found = findFile(fileUri)
+            ?: return
+        FileEditorManager.getInstance(project).openFile(found, true)
     }
 
-    fun readFile(uri: String): String {
-        return try {
-            val content = ApplicationManager.getApplication().runReadAction<String?> {
-                val virtualFile = LocalFileSystem.getInstance().findFileByPath(UriUtils.parseUri(uri).path)
-                if (virtualFile != null && FileDocumentManager.getInstance().isFileModified(virtualFile)) {
-                    return@runReadAction FileDocumentManager.getInstance().getDocument(virtualFile)?.text
-                }
-                return@runReadAction null
-            }
+    fun saveFile(fileUri: String) {
+        val found = findFile(fileUri)
+            ?: return
+        val manager = FileDocumentManager.getInstance()
+        val document = manager.getDocument(found)
+            ?: return
+        manager.saveDocument(document)
+    }
 
-            if (content != null) {
-                content
-            } else {
-                val file = UriUtils.uriToFile(uri)
-                if (!file.exists() || file.isDirectory) return ""
-                FileInputStream(file).use { fis ->
-                    val sizeToRead = minOf(100000, file.length()).toInt()
-                    val buffer = ByteArray(sizeToRead)
-                    val bytesRead = fis.read(buffer, 0, sizeToRead)
-                    if (bytesRead <= 0) return@use ""
-                    val content = String(buffer, 0, bytesRead, Charset.forName("UTF-8"))
-                    // Remove `\r` characters but preserve trailing newlines to prevent line count discrepancies
-                    val contentWithoutCR = content.replace("\r\n", "\n").replace("\r", "\n")
-                    contentWithoutCR
-                }
-            }
-        } catch (e: Exception) {
-            e.printStackTrace()
-            ""
-        }
+    fun getFileStats(fileUris: List<String>): Map<String, FileStats> =
+        fileUris.mapNotNull { fileUri ->
+            val file = findFile(fileUri)
+                ?: return@mapNotNull null
+            fileUri to FileStats(file.timeStamp, file.length)
+        }.toMap()
+
+    private fun findFile(fileUri: String): VirtualFile? {
+        val noParams = fileUri.substringBefore("?")
+        val normalizedAuthority = normalizeWindowsAuthority(noParams)
+        return VirtualFileManager.getInstance()
+            .refreshAndFindFileByUrl(normalizedAuthority)
+    }
 
+    private fun readDocument(file: VirtualFile, maxLength: Int): String? {
+        val document = FileDocumentManager.getInstance().getDocument(file)
+            ?: return ""
+        val length = min(document.textLength, maxLength)
+        return document.getText(TextRange(0, length))
     }
 
+    private fun normalizeLineEndings(text: String) =
+        text.replace("\r\n", "\n")
+            .replace("\r", "\n")
 
+    private fun normalizeWindowsAuthority(fileUri: String): String {
+        val authorityPrefix = "file://"
+        val noAuthorityPrefix = "file:///"
+        if (fileUri.startsWith(authorityPrefix) && !fileUri.startsWith(noAuthorityPrefix)) {
+            val path = fileUri.substringAfter(authorityPrefix)
+            return "$noAuthorityPrefix$path"
+        }
+        return fileUri
+    }
 }