gitbroker 0.6.6 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ef35d4ad926d8851302c8ed0c6c5be6e0dd70f5207fac41d6fc4f77b02e46b0
-  data.tar.gz: 1c6afa6a9db5082116ecaab590dff94ce6d3ca1527d0459fc9ddf468d77c7abb
+  metadata.gz: d89c372f196a3cd8b81d057f63c8abcdafa765585fcde6abaa15dd8ec81c48bf
+  data.tar.gz: 473d304e0ed3fe9bafc232490e4be505b17b12b09c2cebf6b194d2547b108203
 SHA512:
-  metadata.gz: a784b73eceee92147c09a4a28de801bc40b3b6f93f2d2323c12dcad7c2e7da04901372fd6319464f3a494f4e82c3a12adfc653dcae329e22af3b130be6b54916
-  data.tar.gz: c9aace186cb3e2a3309182e791e53ad3c1553ee167e50951cdab83b35aad0eb19c2f0f1f1bc82d847e1936e11278708d27c6cda0017d7e9854b76630e19b7344
+  metadata.gz: c0d446a0a798acb225933b1cd4c1f31c3425112ac025a2bc684b468e47bc57869b56f892683a4c278cbbb788ac5cd7f5f56fa8286671c98d160d115d72313c4c
+  data.tar.gz: 3914718aa114dfe375b4783dfe9c6d5e0408d43d319c013e400f4628912e15984f937417043409b6dfd9b3766cb2e6c3ed7f2a74ae678cc52813a35f57560f81

data/lib/gitbroker/agent_projects.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Gitbroker
+  # The directories the user's own agents already know: Claude Code lists every project it ran in (~/.claude.json),
+  # Codex every project it trusts (~/.codex/config.toml). They tell where the user keeps code without asking and without
+  # walking the disk. Only the paths are read, and they never leave the machine: the server gets what RepoScanner
+  # finds in them (a repository name and a path), as for any other checkout.
+  module AgentProjects
+    CODEX_PROJECT = /\A\[projects\.(?:"((?:[^"\\]|\\.)*)"|'([^']*)')\]\s*\z/
+
+    def self.paths(home: Dir.home)
+      (claude(File.join(home, ".claude.json")) + codex(File.join(home, ".codex", "config.toml"))).uniq
+    end
+
+    def self.claude(file)
+      projects = File.file?(file) ? JSON.parse(File.read(file))["projects"] : nil
+      projects.is_a?(Hash) ? projects.keys.grep(String) : []
+    rescue JSON::ParserError, SystemCallError
+      []
+    end
+
+    def self.codex(file)
+      return [] unless File.file?(file)
+
+      File.foreach(file).filter_map { |line|
+        match = CODEX_PROJECT.match(line.strip)
+        match && (match[1] ? match[1].gsub(/\\(.)/, '\\1') : match[2])
+      }
+    rescue SystemCallError
+      []
+    end
+  end
+end

data/lib/gitbroker/cli.rb

@@ -81,7 +81,7 @@ module Gitbroker
 
     private
 
-    def config = @config ||= Config.load(dir: Config.default_dir(@env), env: @env)
+    def config = @config ||= Config.load(dir: Config.default_dir(@env), env: @env, home: @home)
 
     def login
       options = {}
@@ -107,7 +107,7 @@ module Gitbroker
       if options[:server]
         # Setting a machine up remembers its server (the background service must use it too). A daemon run by hand only
         # uses it for this run: it must not rewrite the settings the service reads.
-        @config = foreground ? Config.load(dir: Config.default_dir(@env), env: @env.merge("GITBROKER_SERVER" => options[:server])) : config.save!("server" => options[:server])
+        @config = foreground ? Config.load(dir: Config.default_dir(@env), env: @env.merge("GITBROKER_SERVER" => options[:server]), home: @home) : config.save!("server" => options[:server])
       end
 
       return run_daemon if foreground
@@ -250,10 +250,10 @@ module Gitbroker
       @out.puts "Agent:      #{config.agent}"
       @out.puts "Terminal:   #{config.terminal}"
       @out.puts "Hooks:      #{hooks_installer.installed? ? "installed" : "not installed (gitbroker install-hooks)"}"
-      @out.puts "Roots:      #{config.roots.join(", ")}"
+      @out.puts "Roots:      #{config.roots.join(", ")} (plus the projects Claude Code and Codex know)"
       @out.puts "Worktrees:  #{config.worktree_root}"
       @out.puts "Task worktrees: #{Worktree.new(root: config.worktree_root).list.size} (running or kept; `gitbroker clean` removes finished ones)"
-      repositories = RepoScanner.new(roots: config.roots, depth: config.scan_depth, exclude: [ config.worktree_root ]).scan
+      repositories = config.repo_scanner.scan
       @out.puts "Repositories found: #{repositories.size}"
       repositories.each { @out.puts "  #{_1["full_name"]}  #{_1["path"]}" }
     end

data/lib/gitbroker/config.rb

@@ -13,22 +13,46 @@ module Gitbroker
     DEFAULT_CLAUDE_ARGS = %w[--permission-mode auto --permission-prompts none].freeze
     DEFAULT_CODEX_ARGS = %w[--sandbox workspace-write -c sandbox_workspace_write.network_access=true].freeze
     # Git Broker sets these itself for every run; user args may not override them.
+    # Where people usually keep code; the ones that exist are always scanned (with `roots` and the agents' project lists).
+    COMMON_ROOTS = %w[~/Code ~/code ~/Projects ~/projects ~/Developer ~/dev ~/src ~/repos ~/workspace ~/work ~/git ~/github ~/Sites].freeze
     RESERVED_ARGS = %w[-p --print --output-format --mcp-config --strict-mcp-config --plugin-dir --json].freeze
 
-    attr_reader :dir, :data
+    attr_reader :dir, :data, :home
 
     def self.default_dir(env = ENV)
       env["GITBROKER_CONFIG_DIR"] || File.join(env["XDG_CONFIG_HOME"] || File.join(Dir.home, ".config"), "gitbroker")
     end
 
-    def self.load(dir: default_dir, env: ENV, platform: Gitbroker.platform)
+    def self.common_roots(home = Dir.home)
+      COMMON_ROOTS.map { File.expand_path(_1.sub("~", home)) }.select { File.directory?(_1) }.uniq { _1.downcase }
+    end
+
+    MAX_DEVICE_ROOTS = 20
+
+    # The folders the user added in Git Broker (a "roots" message from the server). The server is not trusted with more
+    # than a list of existing-looking absolute folders: no home folder, no "/", a bounded count.
+    def self.clean_device_roots(list, home: Dir.home)
+      home = File.expand_path(home)
+      Array(list).first(MAX_DEVICE_ROOTS * 2).filter_map { |entry|
+        next unless entry.is_a?(String) && entry.length <= 500 && !entry.include?("\0")
+
+        entry = entry.strip
+        next unless entry.start_with?("/", "~/")
+
+        path = File.expand_path(entry.sub(/\A~/, home))
+        path unless path == home || path == "/"
+      }.uniq.first(MAX_DEVICE_ROOTS)
+    end
+
+    def self.load(dir: default_dir, env: ENV, platform: Gitbroker.platform, home: Dir.home)
       path = File.join(dir, "config.yml")
       data = File.exist?(path) ? YAML.safe_load_file(path) || {} : {}
-      new(dir:, data:, env:, platform:)
+      new(dir:, data:, env:, platform:, home:)
     end
 
-    def initialize(dir:, data: {}, env: ENV, platform: Gitbroker.platform)
+    def initialize(dir:, data: {}, env: ENV, platform: Gitbroker.platform, home: Dir.home)
       @dir = dir
+      @home = home
       @data = data.to_h.transform_keys(&:to_s)
       @env = env
       @platform = platform
@@ -37,10 +61,18 @@ module Gitbroker
 
     def server = (@env["GITBROKER_SERVER"] || data["server"] || DEFAULT_SERVER).to_s.chomp("/")
     def cable_url = "#{server.sub(/\Ahttp/, "ws")}/cable"
-    def roots = Array(data["roots"] || [ "~/Code" ]).map { File.expand_path(_1) }
+    # `roots` in config.yml and the folders added in Git Broker (`device_roots`) add to the usual folders; the checkouts Claude Code and Codex know come in through `repo_scanner`.
+    def device_roots = self.class.clean_device_roots(data["device_roots"], home:)
+    def ignored_roots = self.class.clean_device_roots(data["ignored_roots"], home:)
+    def roots = (self.class.common_roots(home) + Array(data["roots"]).map { File.expand_path(_1.to_s.sub(/\A~/, home)) } + device_roots).uniq
+    # Folders the user removed in Git Broker (`ignored_roots`) are skipped everywhere except inside a folder they added.
+    def repo_scanner
+      RepoScanner.new(roots: roots - device_roots, explicit_roots: device_roots, depth: scan_depth, exclude: [ worktree_root ],
+                      ignored: ignored_roots, hints: AgentProjects.paths(home:), home:)
+    end
     def scan_depth = Integer(data["scan_depth"] || 3)
     def terminal = (data["terminal"] || (@platform == "macos" ? "terminal" : "tmux")).to_s
-    def worktree_root = File.expand_path(data["worktree_root"] || "~/.local/share/gitbroker/worktrees")
+    def worktree_root = File.expand_path(data["worktree_root"] || File.join(home, ".local/share/gitbroker/worktrees"))
     def state_dir = File.expand_path(data["state_dir"] || "~/.local/state/gitbroker")
     def agent = (data["agent"] || "claude").to_s
     def claude_command = (data["claude_command"] || "claude").to_s
@@ -57,7 +89,7 @@ module Gitbroker
       merged = data.merge(updates.transform_keys(&:to_s)).compact
       FileUtils.mkdir_p(dir, mode: 0o700)
       File.write(File.join(dir, "config.yml"), merged.to_yaml)
-      self.class.new(dir:, data: merged, env: @env, platform: @platform)
+      self.class.new(dir:, data: merged, env: @env, platform: @platform, home:)
     end
 
     def save_credentials!(device_token:, device_id:)

data/lib/gitbroker/daemon.rb

@@ -23,12 +23,22 @@ module Gitbroker
                    process_scanner: build_process_scanner(config))
       raise Error, "This machine is not paired. Run `gitbroker start` in a terminal to pair it." unless config.paired?
 
-      new(scanner: RepoScanner.new(roots: config.roots, depth: config.scan_depth, exclude: [ config.worktree_root ]),
+      new(scanner: config.repo_scanner, roots_changed: roots_changed(config), device_roots: config.device_roots, ignored_roots: config.ignored_roots,
           client_factory: -> { CableClient.new(url: config.cable_url, token: config.device_token, origin: config.server) },
           task_runner_factory: ->(report) { TaskRunner.new(config:, report:, out:) }, out:, relay:, process_scanner:,
           lifecycle: Lifecycle.new(dir: config.dir, server: config.server))
     end
 
+    # The server's "roots" message: remember the folders in config.yml (so they survive a restart without the server) and
+    # scan with them from now on. Returns the new scanner.
+    def self.roots_changed(config)
+      current = config
+      lambda do |roots, ignored|
+        current = current.save!("device_roots" => roots.empty? ? nil : roots, "ignored_roots" => ignored.empty? ? nil : ignored)
+        current.repo_scanner
+      end
+    end
+
     # Claude sessions with hooks installed report real working/waiting status, so the scanner only looks for `claude`
     # without hooks (checked on every scan, so installing hooks takes effect without a restart). Git Broker's own
     # worktrees are skipped: those agents are tasks, reported by the task.
@@ -44,8 +54,11 @@ module Gitbroker
 
     def initialize(scanner:, client_factory:, task_runner_factory:, out: $stdout, sleeper: ->(seconds) { sleep(seconds) },
                    clock: -> { Time.now }, spawner: ->(&block) { Thread.new(&block) }, relay: nil, process_scanner: nil, lifecycle: nil,
-                   maintenance: Maintenance.new)
+                   maintenance: Maintenance.new, roots_changed: nil, device_roots: [], ignored_roots: [])
       @scanner = scanner
+      @device_roots = device_roots
+      @ignored_roots = ignored_roots
+      @roots_changed = roots_changed
       @client_factory = client_factory
       @task_runner = task_runner_factory.call(method(:report))
       @out = out
@@ -209,6 +222,7 @@ module Gitbroker
 
     def handle(client, message)
       return control(message["action"]) if message["type"] == "control"
+      return apply_roots(client, message["roots"], message["ignored"]) if message["type"] == "roots"
 
       id = message["task_id"]
       return unless id.is_a?(String)
@@ -220,6 +234,20 @@ module Gitbroker
       end
     end
 
+    # Sent on every connection and whenever the user changes the list. Nothing happens when it is what we already scan.
+    def apply_roots(client, roots, ignored)
+      return unless @roots_changed
+
+      clean = Config.clean_device_roots(roots, home: Dir.home)
+      clean_ignored = Config.clean_device_roots(ignored, home: Dir.home)
+      return if clean == @device_roots && clean_ignored == @ignored_roots
+
+      @device_roots = clean
+      @ignored_roots = clean_ignored
+      @scanner = @roots_changed.call(clean, clean_ignored)
+      rescan(client)
+    end
+
     def start_task(id, message)
       return unless @running_lock.synchronize { !@upgrading && @running.add?(id) } # the upgrade's restart would kill it
 

data/lib/gitbroker/repo_scanner.rb

@@ -4,7 +4,7 @@ module Gitbroker
   # Finds GitHub checkouts under the configured roots and reports them (DeviceRepository), so a card only offers
   # agents where a checkout exists. Reads .git/config as a file; never runs git in scanned directories.
   class RepoScanner
-    GITHUB_URL = %r{\A(?:https://github\.com/|git@github\.com:|ssh://git@github\.com/)([\w.-]+)/([\w.-]+?)(?:\.git)?/?\z}
+    GITHUB_URL = %r{\A(?:https://(?:[^@/\s]+@)?github\.com/|git@github\.com:|ssh://git@github\.com/)([\w.-]+)/([\w.-]+?)(?:\.git)?/?\z}
     SKIP = %w[node_modules vendor tmp log].freeze
 
     def self.full_name_from(url)
@@ -12,34 +12,72 @@ module Gitbroker
       match && "#{match[1]}/#{match[2]}".downcase
     end
 
-    def initialize(roots:, depth: 3, exclude: [])
+    # `hints` are directories known to hold work (the agents' project lists): each counts as a checkout when it, or a
+    # parent up to HINT_LEVELS above it, is one, however deep it is. Its parent folder is scanned too (HINT_PARENT_DEPTH
+    # levels), because the user keeps the other repositories next to it, where no agent has run. A parent that is the home
+    # folder (or above it) is never scanned: that is the whole account, not a place for code.
+    HINT_LEVELS = 4
+    HINT_PARENT_DEPTH = 2
+
+    # `exclude` (the task worktrees) is skipped everywhere. `ignored` (folders the user removed) is skipped by everything
+    # found by itself; `explicit_roots` (folders the user added) are scanned even inside an ignored folder.
+    def initialize(roots:, depth: 3, exclude: [], hints: [], home: Dir.home, explicit_roots: [], ignored: [])
       @roots = roots
+      @explicit_roots = explicit_roots
+      @ignored = ignored.map { File.expand_path(_1) }
+      @hints = hints
+      @home = File.expand_path(home)
       @depth = depth
       @exclude = exclude.map { File.expand_path(_1) }
+      @skip = @exclude + @ignored
     end
 
     def scan
       found = {}
-      @roots.each { |root| walk(File.expand_path(root), 0, found) if File.directory?(root) }
+      @roots.each { |root| walk(File.expand_path(root), 0, found, @depth, @skip) if File.directory?(root) }
+      @explicit_roots.each { |root| walk(File.expand_path(root), 0, found, @depth, @exclude) if File.directory?(root) }
+      parents = @hints.filter_map { |hint| add_hint(File.expand_path(hint), found) }.map { File.dirname(_1) }.uniq
+      parents.each { |parent| walk(parent, 0, found, HINT_PARENT_DEPTH, @skip) if scannable_parent?(parent) }
       found.sort.map { |full_name, path| { "full_name" => full_name, "path" => path } }
     end
 
     private
 
-    def walk(dir, level, found)
-      return if @exclude.any? { |excluded| dir == excluded || dir.start_with?("#{excluded}/") }
+    # Records the checkout a hint is in and returns its directory (nil when it is not in one).
+    def add_hint(dir, found)
+      HINT_LEVELS.times do
+        return nil if @skip.any? { |skipped| dir == skipped || dir.start_with?("#{skipped}/") }
+        return nil unless File.directory?(dir)
+
+        if File.exist?(File.join(dir, ".git"))
+          remote_names(dir).each { |name| found[name] = dir if found[name].nil? || dir.length < found[name].length }
+          return dir
+        end
+        dir = File.dirname(dir)
+      end
+      nil
+    end
+
+    def scannable_parent?(dir)
+      return true if dir.start_with?("#{@home}/")
+
+      !(dir == @home || dir == "/" || @home.start_with?("#{dir}/"))
+    end
+
+    def walk(dir, level, found, limit, skip)
+      return if skip.any? { |skipped| dir == skipped || dir.start_with?("#{skipped}/") }
 
       if File.exist?(File.join(dir, ".git"))
         remote_names(dir).each { |name| found[name] = dir if found[name].nil? || dir.length < found[name].length }
         return
       end
-      return if level >= @depth
+      return if level >= limit
 
       Dir.children(dir).sort.each do |child|
         next if child.start_with?(".") || SKIP.include?(child)
 
         path = File.join(dir, child)
-        walk(path, level + 1, found) if File.directory?(path) && !File.symlink?(path)
+        walk(path, level + 1, found, limit, skip) if File.directory?(path) && !File.symlink?(path)
       end
     rescue Errno::EACCES, Errno::ENOENT, Errno::ENOTDIR
       nil

data/lib/gitbroker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gitbroker
-  VERSION = "0.6.6"
+  VERSION = "0.7.1"
 end

data/lib/gitbroker.rb

@@ -13,6 +13,7 @@ module Gitbroker
   # Loads every autoloaded constant. Called before `gem cleanup` removes the files of the running version.
   def self.eager_load! = constants.each { const_get(_1) }
 
+  autoload :AgentProjects, File.expand_path("gitbroker/agent_projects", __dir__)
   autoload :Agents, File.expand_path("gitbroker/agents", __dir__)
   autoload :Api, File.expand_path("gitbroker/api", __dir__)
   autoload :BranchPublisher, File.expand_path("gitbroker/branch_publisher", __dir__)

data/plugin/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "gitbroker",
-  "version": "0.6.6",
+  "version": "0.7.1",
   "description": "Skills for working on Git Broker agent tasks: the gitbroker MCP tools, write rules and report_task."
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitbroker
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.7.1
 platform: ruby
 authors:
 - Yuri Sidorov (@newstler)
@@ -34,6 +34,7 @@ files:
 - LICENSE.txt
 - exe/gitbroker
 - lib/gitbroker.rb
+- lib/gitbroker/agent_projects.rb
 - lib/gitbroker/agents.rb
 - lib/gitbroker/agents/base.rb
 - lib/gitbroker/agents/claude.rb