@sewbacca I put our discussion into sonnet4 and here is its reply 👀

In short, the workspace.ignoreLibraryDir seems to be a simple enough solution for now.
But as you have said, it is clearly not an elegant solution for long-term. 🤔

Per library config ignoreDir

Meanwhile, your idea of making ignoreDir to be a per library config is brilliant. 👀
With the insight of sonnet4, I come up with an approach with nearly NO API changes 💡🤯

• if a path in ignoreDir contains a : separator => it is a {library}:{path} config
  which only applies to the same library path specified in workspace.library
• In your use case, the config will be like the following:

{
    "workspace.library": [ "/usr/share/lua/5.4" ],
    "workspace.ignoreDir": ["/usr/share/lua/5.4:<mymodule>"]
}

=> this means the <mymodule> gitignore pattern will only applies to /usr/share/lua/5.4 library path

• in this way we keep the functionality of gitignore pattern, while avoiding the handling absolute path issue in a gitignore pattern.

Implementation idea

The existing m.getLibraryMatchers logic already creates a separate matcher for each library path.
just that they are all using the same pattern[] array

• if a path contains :, separate it into {library} and {path}
• use a table libraryPattern{ files.normalize(library) => [ path, ... ] } to store patterns that are specific for this library
• and while constructing per library matcher, we append the pattern[] array into each libraryPattern[path] array

POC

I just did a POC in local and it seems to work as expected 🎉
My test config:

• workspace root: ~/test
  • mylib/b.lua
  • main.lua
• library: ~/lib
  • a.lua
  • mylib/b.lua
• to achieve that requiring mylib.b in main.lua will only use workspace's ~/test/mylib/b.lua
  I can use the following config

{
    "workspace.library": ["~/lib"],
    "workspace.ignoreDir": ["~/lib:mylib"]
}

Here's a patch file that you might want to try 👀
You may need to test it more thoroughly and add some changelog before opening a PR for it 😄

From 75421973545071438f466686febe77b746aa5d36 Mon Sep 17 00:00:00 2001
From: Tom Lau <[email protected]>
Date: Tue, 1 Jul 2025 10:36:02 +0800
Subject: [PATCH] feat: support per library ignoreDir in format
 `{library}:{path}`

---
 script/workspace/workspace.lua | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/script/workspace/workspace.lua b/script/workspace/workspace.lua
index d5868342..7732b4e7 100644
--- a/script/workspace/workspace.lua
+++ b/script/workspace/workspace.lua
@@ -210,6 +210,7 @@ function m.getLibraryMatchers(scp)
     log.debug('Build library matchers:', scp)
 
     local pattern = {}
+    local libraryPattern = {}
     for path, ignore in pairs(config.get(scp.uri, 'files.exclude')) do
         if ignore then
             log.debug('Ignore by exclude:', path)
@@ -218,29 +219,47 @@ function m.getLibraryMatchers(scp)
     end
     for _, path in ipairs(config.get(scp.uri, 'Lua.workspace.ignoreDir')) do
         log.debug('Ignore directory:', path)
-        pattern[#pattern+1] = path
+        if path:find(':', 1, true) then
+            -- this is a "{library}:{path}" which only applies to specfic library path
+            local libraryPath, subPath = path:match("([^:]+):(.+)")
+            libraryPath = libraryPath and m.getAbsolutePath(scp.uri, libraryPath)
+            if libraryPath ~= nil then
+                libraryPattern[libraryPath] = libraryPattern[libraryPath] or {}
+                table.insert(libraryPattern[libraryPath], subPath)
+            end
+        else
+            pattern[#pattern+1] = path
+        end
     end
 
+    ---@type table<string, string[]> # { [libraryPath] = ignorePattern[] }
     local librarys = {}
     for _, path in ipairs(config.get(scp.uri, 'Lua.workspace.library')) do
         path = m.getAbsolutePath(scp.uri, path)
         if path then
-            librarys[files.normalize(path)] = true
+            local libraryPath = files.normalize(path)
+            if libraryPattern[libraryPath] then
+                -- merge default pattern[] to libraryPattern
+                util.arrayMerge(libraryPattern[libraryPath], pattern)
+            else
+                -- use default pattern[]
+                librarys[libraryPath] = pattern
+            end
         end
     end
     local metaPaths = scp:get 'metaPaths'
     log.debug('meta path:', inspect(metaPaths))
     if metaPaths then
         for _, metaPath in ipairs(metaPaths) do
-            librarys[files.normalize(metaPath)] = true
+            librarys[files.normalize(metaPath)] = pattern
         end
     end
 
     local matchers = {}
-    for path in pairs(librarys) do
+    for path, patterns in pairs(librarys) do
         if fs.exists(fs.path(path)) then
             local nPath = fs.absolute(fs.path(path)):string()
-            local matcher = glob.gitignore(pattern, {
+            local matcher = glob.gitignore(patterns, {
                 root       = path,
                 ignoreCase = platform.os == 'windows',
             }, globInteferFace)
-- 
2.47.1.windows.2

@tomlau10 I haven't tested it yet, but absolute paths on windows start with <driveletter>:[/\] or just with a [/\]. Your patch appears to not respect that. Either try all sub-paths until a : to test against a library or we use another character.

We also could simply check if the prefix matches a library path and if it does, use the suffix (skipping an initial directory seperator) as a gitignore pattern. You'd need to do this check from longest library paths to the shortest though to be unambiguous. I'm not sure if it is necessary, though. Ideally this check should only be performed if the path is absolute (starts with slash inclusive-or on windows starts with a letter colon directory separator). This would be more akin my first proposal.

I agree though that fixing it in ignoreDir is the best way for now.

P.S. I understand that everybody is using AI nowadays and at times it really is a good tool. However I am not particularly happy that you fed our discussion to an AI. I appreciate your transparency though.

but absolute paths on windows start with <driveletter>:[/\] or just with a [/\]. Your patch appears to not respect that. Either try all sub-paths until a : to test against a library or we use another character.

@sewbacca Yes, you're right. Windows' paths containing a : certainly complicates the issue... 🤦‍♂️
And from the wiki page: https://en.wikipedia.org/wiki/Filename#Comparison_of_filename_limitations
There doesn't seems to be a character which is reserved across all file system 🙄

Maybe we should just do best effort support, and at most add some special detection on the path

• assume absolute path on windows will only be <driveletter>:[/\]
  => that means the : will be on string index 2
• with this assumption, we can then search for another : starting from index 3
  => such that it won't flag incorrectly if it is just a windows abs path
• finally use greedy match pattern (.+):(.+)
  => in this way we can match the rightmost : suffix as the gitignore pattern

New Patch and testing

From c4b31ee522a451df450fca5b9be96908f5a7cb88 Mon Sep 17 00:00:00 2001
From: Tom Lau <[email protected]>
Date: Tue, 1 Jul 2025 10:36:02 +0800
Subject: [PATCH] feat: support per library ignoreDir in format
 `{library}:{path}`

---
 script/workspace/workspace.lua | 28 +++++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/script/workspace/workspace.lua b/script/workspace/workspace.lua
index d5868342..40d25dc1 100644
--- a/script/workspace/workspace.lua
+++ b/script/workspace/workspace.lua
@@ -210,6 +210,7 @@ function m.getLibraryMatchers(scp)
     log.debug('Build library matchers:', scp)
 
     local pattern = {}
+    local libraryPattern = {}
     for path, ignore in pairs(config.get(scp.uri, 'files.exclude')) do
         if ignore then
             log.debug('Ignore by exclude:', path)
@@ -218,29 +219,46 @@ function m.getLibraryMatchers(scp)
     end
     for _, path in ipairs(config.get(scp.uri, 'Lua.workspace.ignoreDir')) do
         log.debug('Ignore directory:', path)
-        pattern[#pattern+1] = path
+        if path:find(':', 3, true) then
+            -- this is a "{library}:{path}" which only applies to specfic library path
+            local libraryPath, subPath = path:match("(.+):(.+)")
+            libraryPath = libraryPath and m.getAbsolutePath(scp.uri, libraryPath)
+            if libraryPath ~= nil then
+                libraryPath = files.normalize(libraryPath)
+                libraryPattern[libraryPath] = libraryPattern[libraryPath] or {}
+                table.insert(libraryPattern[libraryPath], subPath)
+            end
+        else
+            pattern[#pattern+1] = path
+        end
     end
 
+    ---@type table<string, string[]> # { [libraryPath] = ignorePattern[] }
     local librarys = {}
     for _, path in ipairs(config.get(scp.uri, 'Lua.workspace.library')) do
         path = m.getAbsolutePath(scp.uri, path)
         if path then
-            librarys[files.normalize(path)] = true
+            local libraryPath = files.normalize(path)
+            if libraryPattern[libraryPath] then
+                -- merge default pattern[] to libraryPattern
+                util.arrayMerge(libraryPattern[libraryPath], pattern)
+            end
+            librarys[libraryPath] = libraryPattern[libraryPath] or pattern
         end
     end
     local metaPaths = scp:get 'metaPaths'
     log.debug('meta path:', inspect(metaPaths))
     if metaPaths then
         for _, metaPath in ipairs(metaPaths) do
-            librarys[files.normalize(metaPath)] = true
+            librarys[files.normalize(metaPath)] = pattern
         end
     end
 
     local matchers = {}
-    for path in pairs(librarys) do
+    for path, patterns in pairs(librarys) do
         if fs.exists(fs.path(path)) then
             local nPath = fs.absolute(fs.path(path)):string()
-            local matcher = glob.gitignore(pattern, {
+            local matcher = glob.gitignore(patterns, {
                 root       = path,
                 ignoreCase = platform.os == 'windows',
             }, globInteferFace)
-- 
2.47.1.windows.2

• and i tested it works with windows absolute path now 🙂

{
    "workspace.library": ["C:\\Users\\TomLau\\lib"],
    "workspace.ignoreDir": ["C:\\Users\\TomLau\\lib:mylib"]
}

We also could simply check if the prefix matches a library path and if it does, use the suffix (skipping an initial directory seperator) as a gitignore pattern

I am not sure if this is 100% correct, because the initial directory separator has meaning in gitignore pattern, which means restrict this only to the (root) directory and not in its subdirectories 😕
Moreover the prefix check approach seems to be quite complicated and error prone?
If possible, I think sticking to the simple separator approach sounds better 🤔 .

However I am not particularly happy that you fed our discussion to an AI

I'm sorry about that. 😓
I just thought that there aren't any personal or sensitive information in the discussion, so I can fed to an AI directly to get some insight.
May I ask which contents you don't want to share with an AI? Your username maybe?
If that's the case, I will remember to strip out every personal identities (or replaces them with I myself) next time before I chat with an AI. 🙏

However I am not particularly happy that you fed our discussion to an AI

I'm sorry about that. 😓 I just thought that there aren't any personal or sensitive information in the discussion, so I can fed to an AI directly to get some insight. May I ask which contents you don't want to share with an AI? Your username maybe? If that's the case, I will remember to strip out every personal identities (or replaces them with I myself) next time before I chat with an AI. 🙏

There are not. I don't like that AI companies are using the work of people, be it code, art or simply ideas, supplied for free use to other human beings in order to train their models without the creators permission and without compensating them while making millions.
I know that they scrape GitHub and a lot of other sites to get their data, so sharing the same info directly in chat is a bit redundant, but you know, I don't like it in principle. And there is a difference between activly sharing that info and them scraping it.

This is however mostly your work, I just threw in some ideas, so for me it's up to you what you wanna share and what you don't.

I find it good practice in general to hide identifiable information as much as possible from a privacy first mindset though.

I understand your perspective completely. This is indeed a serious issue with polarized views in society. I totally agree that the "taking without asking" approach is problematic, especially in areas like AI-generated art. ☹️

However, AI tools seem to be the current trend. Personally, I remain open to using them, but I also hope that society will establish more ethical guidelines for AI data collection in the near future.

Thanks for sharing your thoughts on this! 😄

I haven't tested that either, but shouldn't there be a check if prefix+1 is a directory separator (either forward or backward slash)?

In my mind this solution is more intuitive, but your other solution is more flexible. I think I'd be happy if we merge the two. Have the intuitive ignore an absolute directory, but if an all subdirectory check is wanted, :<.gitignore pattern> should be used.

but shouldn't there be a check if prefix+1 is a directory separator

I understand now 🤦‍♂️

• because if the library path doesn't have a trailing / or \, it might incorrectly match a prefix of a long folder name
• for example C:\\Users\\TomLau\\lib will match the prefix of C:\\Users\\TomLau\\library
  => then my POC code will incorrectly treat the suffix rary as a library specific ignore pattern for C:\\Users\\TomLau\\lib

In my mind this solution is more intuitive, but your other solution is more flexible

After implementing the absolute path approach, I agree that it is much more intuitive👍
And after some though, actually this "absolute path" approach can have gitignore patterns 🤔

• Let's take my above config as an example again

{
    "workspace.library": [ "C:\\Users\\TomLau\\lib" ],
    "workspace.ignoreDir": ["C:\\Users\\TomLau\\lib\\mylib"]
}

• if I want it to be any mylib inside C:\\Users\\TomLau\\lib library
  I can instead use the following in ignoreDir: "C:\\Users\\TomLau\\lib/**/mylib"
  • the suffix / gitignore pattern in this case will be /**/mylib
  • which means
    • starting from the root path
    • with any level of directory in the middle
    • ignore any file or folder named mylib
  • => and it's the same as a pattern of just writing mylib 🤔

(though this is quite ugly..., as it mixed both backward and forward slash 🙈 )

but another thing needs to be fixed first

• In the previous example, the extracted gitignore pattern in "C:\\Users\\TomLau\\lib\\mylib" is \\mylib
  I suddenly feel confused why a \\mylib pattern can do the filtering 😕
  • after some testing, I found that it just ignore my initial \, and treat it like mylib
  • => which will filter any folder named mylib under that library path
  • => this is different from the absolute path C:\\Users\\TomLau\\lib\\mylib
• seems I have to do a subPath:gsub("\\", "/") first after getting the subPath 🤔
  and also I have to make sure that the subPath is formatted with with an initial /
  => to make it always start matching from the root library path
• with this \\ => / conversion, then the ignoreDir path on windows can be written more naturally 🎉

"C:\\Users\\TomLau\\lib\\**\\mylib"

=> the extracted pattern will be transformed to /**/mylib

but if an all subdirectory check is wanted, :<.gitignore pattern> should be used.

The above have explained that the (enhanced) absolute path approach is compatible with writing gitignore patterns
=> as flexible as my original {library}:{pattern} idea
=> thus no more reason to introduce a :<.gitignore pattern> syntax
(which is quite confusing when I look back 🤣 )

I might try to write a new patch tomorrow 😃

It does fix my issue, just tested it :D. I noticed something strange though. On Windows you can actually use / as a directory separator (and capitalization doesn't matter), which means you shouldn't have to copy the path verbatim, but if you don't the fix won't work. Maybe you wanna throw in a :gsub('\\', '/') at the comparision in the for loop where the check is performed for a good measure? I don't know how far we need to go into the rabbit hole of path sanitization though. It's fine for most of my purposes already, it really is.

So thank you for the effort you put into this 🙏🏼

{
	"workspace.ignoreDir": [
		"C:/msys64/ucrt64/share/lua/5.1/<modname>",  // This won't be detected by the patch
		"C:/msys64/ucrt64/share/lua\\5.1/<modname>"  // This does however
	],
	"workspace.library": [
		"C:/msys64/ucrt64/share/lua\\5.1"  // Because the there's a \ before 5.1 and not a forward slash
	]
}

Maybe you wanna throw in a :gsub('\\', '/') at the comparision in the for loop where the check is performed for a good measure? I don't know how far we need to go into the rabbit hole of path sanitization though.

Ah~ I see your point.
And I noticed that there is a files.normalize() function for normalizing a path.
Maybe I should normalize paths while comparing them in the for loop 🤔

• this normalize() will strip any trailing slash in the paths, and unify all path separator
• such that we can only check for leading slash in the extracted subPath to see if library path matches
• and then directly remove the library prefix in the subPath in this normalized form.

I will try to see if the whole logic can be simplified a bit before opening a PR for it 👀

I will try to see if the whole logic can be simplified a bit before opening a PR for it 👀

🤯 I just found a much simpler way to extract the sub path, by using bee.filesystem's fs.relative(path, base)

• this will try to convert path into a relative path format of base (if possible)
• and we can then check if this relative path starts with ..
  • if it starts with .. => this is NOT a sub path under the base path
  • otherwise => this IS a valid sub path under the base path
• this technique has been used here (in PR fix: incorrect file names in doc.json #3070)
  

  lua-language-server/script/cli/doc/export.lua

  Lines 59 to 68 in 32fec3c

  	function export.getLocalPath(uri)
  	local file_canonical = fs.canonical(furi.decode(uri)):string()
  	local doc_canonical = fs.canonical(DOC):string()
  	local relativePath = fs.relative(file_canonical, doc_canonical):string()
  	if relativePath == "" or relativePath:sub(1, 2) == '..' then
  	-- not under project directory
  	return '[FOREIGN] ' .. file_canonical
  	end
  	return relativePath
  	end

From 64f6a38ff4894b3ba9882452194aa6592aa112ff Mon Sep 17 00:00:00 2001
From: Tom Lau <[email protected]>
Date: Thu, 3 Jul 2025 09:46:00 +0800
Subject: [PATCH] feat: support per library ignoreDir when library path prefix
 matched

---
 script/workspace/workspace.lua | 35 ++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/script/workspace/workspace.lua b/script/workspace/workspace.lua
index d5868342..c24648e3 100644
--- a/script/workspace/workspace.lua
+++ b/script/workspace/workspace.lua
@@ -216,9 +216,32 @@ function m.getLibraryMatchers(scp)
             pattern[#pattern+1] = path
         end
     end
+    local libPatterns = {}
     for _, path in ipairs(config.get(scp.uri, 'Lua.workspace.ignoreDir')) do
         log.debug('Ignore directory:', path)
-        pattern[#pattern+1] = path
+        -- check for library specific ignoreDir
+        local isLibPattern = false
+        local nPath = files.normalize(path)
+        for _, libPath in ipairs(config.get(scp.uri, 'Lua.workspace.library')) do
+            -- check if ignoreDir path is relative to libPath
+            local nLibPath = files.normalize(libPath)
+            local libRelativePath = fs.relative(fs.path(nPath), fs.path(nLibPath)):string()
+            if libRelativePath ~= ''   -- will be empty string on windows if drive letter is different
+            and libRelativePath:sub(1, 2) ~= '..'  -- a valid subpath of libPath should not starts with `..`
+            then
+                isLibPattern = true
+                local absLibPath = m.getAbsolutePath(scp.uri, libPath)
+                if absLibPath then
+                    -- add leading `/` to convert subpath to absolute gitignore pattern path
+                    local subPattern = '/' .. libRelativePath
+                    libPatterns[absLibPath] = libPatterns[absLibPath] or {}
+                    table.insert(libPatterns[absLibPath], subPattern)
+                end
+            end
+        end
+        if not isLibPattern then
+            pattern[#pattern+1] = path
+        end
     end
 
     local librarys = {}
@@ -239,8 +262,16 @@ function m.getLibraryMatchers(scp)
     local matchers = {}
     for path in pairs(librarys) do
         if fs.exists(fs.path(path)) then
+            local patterns = libPatterns[path]
+            if patterns then
+                -- append default pattern
+                util.arrayMerge(patterns, pattern)
+            else
+                -- use default pattern
+                patterns = pattern
+            end
             local nPath = fs.absolute(fs.path(path)):string()
-            local matcher = glob.gitignore(pattern, {
+            local matcher = glob.gitignore(patterns, {
                 root       = path,
                 ignoreCase = platform.os == 'windows',
             }, globInteferFace)
-- 
2.47.1.windows.2