🙌 CodeCompanion Rules Extension!

[arnm]

Every project has its own unique set of rules and guidelines—often scattered across different files. Remembering which files to include in your AI chat is a real cognitive burden. This extension solves that by automatically detecting and attaching all relevant rule files (like .rules, AGENT.md, and more) to your chat context. No more manual selection or forgetting important context!

codecompanion-rules.mp4

It works just like other agentic tools you know and love (Cursor, ClaudeCode, etc.):

• Keeps your AI up-to-date with the latest project rules.
• Removes the overhead of managing context files yourself.
• Runs quietly in the background, always keeping your chat in sync.

Add rules in two main ways. In both cases, the rules file for the paths extracted are found and added:

1. When you add a file/buffer reference
2. By default, when you do @files operations (edit, create, read). You can define you own extract from message function

Setup is simple:

1. Grab the code from the gist.
2. Add to your CodeCompanion config:

   rules = {
     opts = {
       rules_filenames = {
         ".rules",
         ".goosehints",
         ".cursorrules",
         ".windsurfrules",
         ".clinerules",
         ".github/copilot-instructions.md",
         "AGENT.md",
         "AGENTS.md",
         "CLAUDE.md",
         ".codecompanionrules",
       },
       debug = false,
       enabled = true,
       extract_file_paths_from_chat_message = nil,
     }
   },

3. Use :CodeCompanionRulesEnable or :CodeCompanionRulesDisable to toggle as needed.

Let your AI focus on your code, not your context—give it a try!

[bassamsdata]

This is awesome, you’re creating so many cool extensions! Thank you for that.

Just yesterday, I converted your other checklist gist into a proper local extension. Today, I was thinking about turning a small script I already have, one that adds my CLAUDE.md rule to my system prompt as a variable, into an extension, but this solution is even better.

That said, these are great extensions, but I’m curious, why not make them into proper extension? Is it because of maintainability concerns? just out of curiousity

[arnm]

Hey!

This is awesome, you’re creating so many cool extensions! Thank you for that.

Thanks, glad people are also finding these helpful :)

Just yesterday, I converted your other checklist gist into a proper local extension

Sweet! I'd love to check it out. The checklist one is really useful but I see claude code and others and they have these automatic checklist utilization so I'm thinking if I can make a more complex extension for robust agentic flows. aka orchestrators, multiple agents etc I think its possible

Today, I was thinking about turning a small script I already have, one that adds my CLAUDE.md rule to my system prompt as a variable, into an extension, but this solution is even better.

Haha great, I had this one half baked for a while and got it to a decent point, I made some minor improvement since the video example so that it works better with /buffer command too

That said, these are great extensions, but I’m curious, why not make them into proper extension? Is it because of maintainability concerns? just out of curiousity

Mainly for the fact that I am hacking these together and yea if I think its good enough for me I may not try to fix all the little bugs. Also I know you for example and others are more familiar with the codebase and plugins in general, so if you find it useful you can give it the proper attention :)

[tristan957]

Do you have any thoughts on adding this to CodeCompanion natively?

[Eckii24]

Awesome extension! Really fills a missing gap between tools.
Beside code companion I'm also using KiloCode (a clone of cline/rooCode). Here we don't define a single rule file, but a rule folder.

I would like to also add folders to the list and add everything recursively inside also to the context.
Any chance, you have this already implemented? Otherwise I will try it myself :)

[minusfive]

Yeah, @olimorris: this feels like may be worth making it a first-class feature.

[minusfive]

So I used it as an excuse to poke at it and learn more about CodeCompanion, extensions, agent rules, etc., and turned this into a plugin / extension:

https://github.com/minusfive/codecompanion-agent-rules

@arnm it's literally copy-pasta, happy to transfer ownership anytime. LMK which license you'd like me to add.

[minusfive]

I've also just updated it to account for the refs -> context_items changes introduced in #1891

[moliyu]

this err will show when use ga accept edtis

[minusfive]

@moliyu hmm, perhaps there are more recent changes to CodeCompanion I need to accommodate. Will try and take a look at some point. Feel free to submit a PR if you figure it out.

(I was perusing the changes since roughly the last time I pushed but out of time atm I'm afraid).

[minusfive]

@moliyu haven't had a chance to dive into it, but I can report that ga works fine for me, but I use the @{neovim} tool built into MCPHub primarily which so far has worked better for me than the CodeCompanion built-in ones.

Figured I'd mention in case you'd like to give that a try.

[moliyu]

@minusfive yes, it works fine with "neovim__edit_file"

[seblyng]

Something like this:

vim.api.nvim_create_autocmd("User", {
    pattern = "CodeCompanionChatCreated",
    callback = function(event)
        local chat = require("codecompanion").buf_get_chat(event.data.bufnr)
        if not chat then
            return
        end

        local rule_files = {
            ".github/copilot-instructions.md",
        }

        local slash_commands = require("codecompanion.strategies.chat.slash_commands")
        local start_path = vim.fs.dirname(vim.api.nvim_buf_get_name(0))
        local found_files = {}

        local function try_add_context(dir)
            for _, rule in ipairs(rule_files) do
                local path = vim.fs.joinpath(dir, rule)
                if vim.uv.fs_stat(path) and not vim.list_contains(found_files, path) then
                    table.insert(found_files, path)
                    slash_commands.context(chat, "file", { path = path })
                end
            end
        end

        try_add_context(start_path)
        for dir in vim.fs.parents(start_path) do
            try_add_context(dir)
        end
    end,
})

also seems to be minimal and work pretty much how I want it to. Automatically add a file to the context if it exists

[moliyu]

it works fine and I make some change with this funciton to add the support of glob match. TKs.

    local function try_add_context(dir)
      for _, rule in ipairs(rule_files) do
        local matched_files = vim.fn.glob(vim.fs.joinpath(dir, rule), true, true)
        for _, path in ipairs(matched_files) do
          if not vim.list_contains(found_files, path) then
            table.insert(found_files, path)
            slash_commands.context(chat, "file", { path = path })
          end
        end
      end
    end