Kobold 0.3.3 → 0.4.0

data/lib/Kobold/invoke.rb

@@ -1,200 +1,20 @@
 # frozen_string_literal: true
 
-require "tty-config"
-require 'fileutils'
-require 'git'
-
-#require_relative "Kobold/vars.rb"
-
 module Kobold
   class << self
-    def invoke
-      Kobold.first_time_setup if !File.directory? "#{KOBOLD_DIR}/repo_cache"
-      if !File.file? "#{Dir.pwd}/.kobold"
-        puts "ERROR: Kobold file not found at '#{Dir.pwd}'"
-        return
-      end
-      settings = Kobold.read_config(Dir.pwd)
-
-      if Kobold::FORMAT_VERSION == settings["_kobold_config"]["format_version"]
-        # iterate over all dependencies
-        settings.each do |key, value|
-          if key[0] == '_' 
-            next
-          end
-          repo_dir = "#{KOBOLD_DIR}/repo_cache/#{value['repo'].gsub('/', '-')}"
-
-          source_repo = nil;
-          # check if source exists
-          if !Dir.exist? "#{repo_dir}/source" # TODO: make this properly check for git repo
-            # if it doesnt, make it
-            FileUtils.mkdir_p "#{repo_dir}/source"
-            FileUtils.mkdir_p "#{repo_dir}/worktrees"
-            FileUtils.mkdir_p "#{repo_dir}/worktrees/branched"
-            FileUtils.mkdir_p "#{repo_dir}/worktrees/sha"
-            FileUtils.mkdir_p "#{repo_dir}/worktrees/labelled"
-            FileUtils.mkdir_p "#{repo_dir}/branches"
-            source_repo = clone_git_repo "#{value["source"]}/#{value['repo']}.git", "#{repo_dir}/source" 
-          else
-            source_repo = Git.open("#{repo_dir}/source")
-          end
-
-          # must be scoped here, used in various inner scopes
-          target_symlink = nil
-
-          #   Structure of a segment of following code:
-          # if it declares a branch: make the branch
-          # if it has a label
-          #   it must have a sha
-          #   if it has a branch
-          #     use that branch + sha
-          #   else
-          #     use source + sha
-          #   end
-          # else check if it has a branch
-          #   if it has a sha
-          #     make the sha
-          #   else
-          #     make it point to branch
-          #   end
-          # else check if it has a sha
-          #   make the sha on the source
-          # else
-          #   use source
-          # end
-
-          branch_repo = nil
-          if value["branch"]
-            branch_repo_path = "#{repo_dir}/branches/#{value["branch"]}"
-            # check if branch already exists, make it if it doesnt
-            if !Dir.exist? branch_repo_path
-              FileUtils.mkdir_p "#{repo_dir}/branches"
-              source_repo.worktree(branch_repo_path, value["branch"]).add
-            end
-            branch_repo = Git.open(branch_repo_path)
-          end
-
-          target_symlink = nil
-          # if it has a label
-          if value["label"]
-
-            if !value["commit"]
-              raise "Must give a specific sha when making a label. #{key} has no specific sha given"
-            end
-            if value["branch"]
-              worktree_path = "#{repo_dir}/worktrees/labelled/#{value["label"]}/#{value["branch"]}"
-              _commit_val = value["commit"].to_s.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'")
-              worktree_sha = branch_repo.object(_commit_val).sha;
-              target_symlink = "#{worktree_path}/#{worktree_sha}"
-              if !Dir.exist? target_symlink
-                FileUtils.mkdir_p "#{worktree_path}"
-                branch_repo.worktree(target_symlink, worktree_sha).add
-              end
-            else
-              branch = source_repo.branch.name
-              worktree_path = "#{repo_dir}/worktrees/labelled/#{value["label"]}/#{branch}"
-              _commit_val = value["commit"].to_s.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'")
-              worktree_sha = source_repo.object(_commit_val).sha;
-              target_symlink = "#{worktree_path}/#{worktree_sha}"
-              if !Dir.exist? target_symlink
-                FileUtils.mkdir_p "#{worktree_path}"
-                source_repo.worktree(target_symlink, worktree_sha).add
-              end
-            end
-
-          elsif value["branch"]
-
-            if value['sha']
-              worktree_path = "#{repo_dir}/worktrees/branched/#{branch}"
-              _commit_val = value["commit"].to_s.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'")
-              worktree_sha = branch_repo.object(_commit_val).sha;
-              target_symlink = "#{worktree_path}/#{worktree_sha}"
-              if !Dir.exist? target_symlink
-                FileUtils.mkdir_p "#{worktree_path}"
-                branch_repo.worktree(target_symlink, worktree_sha).add
-              end
-            else
-              target_symlink = "#{repo_dir}/branches/#{value['branch']}"
-            end
-
-          elsif value["commit"]
-
-            worktree_path = "#{repo_dir}/worktrees/sha"
-            _commit_val = value["commit"].to_s.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'")
-            worktree_sha = source_repo.object(_commit_val).sha;
-            target_symlink = "#{worktree_path}/#{worktree_sha}"
-            if !Dir.exist? target_symlink
-              FileUtils.mkdir_p "#{worktree_path}"
-              source_repo.worktree(target_symlink, worktree_sha).add
-            end
-
-          else
-
-            target_symlink = "#{repo_dir}/source"
-
-          end
-
-          # build the symlink
-          if value["dir"].end_with? "/"
-            FileUtils.mkdir_p value["dir"]
-            #puts "value: " + value["dir"] + key.split('/').last
-            #puts !File.symlink?(value["dir"] + key.split('/').last)
-
-            symlink1 = File.symlink?(value["dir"] + value['repo'].split('/').last)
-            symlink2 = File.symlink? value["dir"]
-
-            if !(symlink1 || symlink2)
-              File.symlink(target_symlink, "#{value['dir']}/#{value['repo'].split('/').last}")
-            end
-            #File.symlink(target_symlink, "#{value['dir']}/#{key.split('/').last}")
-
-          else
-            dir_components = value["dir"].split "/"
-            dir_components.pop
-            dir_components = dir_components.join "/"
-            FileUtils.mkdir_p dir_components
-            File.symlink(target_symlink, value["dir"]) if !File.symlink? value["dir"]
-
-            symlink1 = File.symlink?(value["dir"] + value['repo'].split('/').last)
-            symlink2 = File.symlink? value["dir"]
-
-            if !(symlink1 || symlink2)
-              File.symlink(target_symlink, value["dir"])
-            end
-            #File.symlink(target_symlink, value["dir"])
-          end
-
-        end
-
-        # iterate over all sub kobold files
-        sub_kobolds = if settings["_kobold_include"] then settings["_kobold_include"]["files"].strip.split("\n") else [] end
-        sub_kobolds.each do |path|
-          Dir.chdir(path.strip) do
-            invoke
-          end
-        end
-
-      else
-        raise "Wrong format version"
-      end
+    # Process a .kobold config file: clone/fetch repos, create worktrees,
+    # and symlink them into the project directory.
+    #
+    # This is a convenience wrapper around Kobold::Manager#invoke.
+    #
+    # @param config_path [String] path to the .kobold file (default: current dir)
+    # @param database_name [String] which database to use (default: "default")
+    # @return [Array<Hash>] results for each dependency processed
+    def invoke(config_path: Dir.pwd, database_name: "default")
+      manager = Manager.new(database: database_name)
+      results = manager.invoke(config_path: config_path)
       puts "Done!"
-    end
-
-    private
-
-    def clone_git_repo(url, path)
-      progress_bar = TTY::ProgressBar.new("[:bar] Cloning: #{url} ", bar_format: :blade, total: nil, width: 45)
-
-      thread = Thread.new(abort_on_exception: true) do
-        Git.clone url, path
-      end
-      progress_bar.start
-      while thread.status
-        progress_bar.advance
-        sleep 0.016
-      end
-      puts
-      return thread.value
+      results
     end
   end
 end

data/lib/Kobold/linker.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Kobold
+  # Handles symlink creation, validation, and cleanup.
+  #
+  # All methods are module-level (stateless).
+  module Linker
+    module_function
+
+    # Create a symlink from target to destination.
+    #
+    # If destination ends with "/", the symlink is created inside that directory
+    # using the basename of the target.
+    #
+    # @param target [String] what the symlink points to (the worktree path)
+    # @param destination [String] where the symlink is placed
+    # @return [String] the actual symlink path created
+    def link(target, destination)
+      symlink_path = resolve_destination(target, destination)
+
+      if File.symlink?(symlink_path)
+        return symlink_path if existing_symlink_matches?(symlink_path, target)
+
+        File.delete(symlink_path)
+      elsif File.exist?(symlink_path)
+        remove_existing_path(symlink_path)
+      end
+
+      FileUtils.mkdir_p(File.dirname(symlink_path))
+      File.symlink(target, symlink_path)
+      symlink_path
+    end
+
+    # Remove a symlink at destination.
+    #
+    # @param destination [String] the symlink path
+    # @return [void]
+    def unlink(destination)
+      return unless File.symlink?(destination)
+
+      File.delete(destination)
+    end
+
+    # Remove an existing symlink and create a new one.
+    #
+    # @param target [String] what the new symlink points to
+    # @param destination [String] where the symlink is placed
+    # @return [String] the symlink path
+    def relink(target, destination)
+      symlink_path = resolve_destination(target, destination)
+      unlink(symlink_path)
+      link(target, destination)
+    end
+
+    # Check if a symlink at destination is valid (exists and points to a real path).
+    #
+    # @param destination [String] the symlink path
+    # @return [Boolean]
+    def valid?(destination)
+      File.symlink?(destination) && File.exist?(destination)
+    end
+
+    # @api private
+    def resolve_destination(target, destination)
+      if destination.end_with?("/")
+        FileUtils.mkdir_p(destination)
+        File.join(destination, File.basename(target))
+      else
+        destination
+      end
+    end
+
+    # @api private
+    def existing_symlink_matches?(symlink_path, target)
+      existing = File.readlink(symlink_path)
+      resolved = File.expand_path(existing, File.dirname(symlink_path))
+      resolved == File.expand_path(target)
+    end
+
+    # @api private
+    def remove_existing_path(path)
+      FileUtils.rm_rf(path)
+    end
+  end
+end

data/lib/Kobold/manager/checkout.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Kobold
+  class Manager
+    # Checkout, branching, and worktree management methods.
+    module Checkout
+      # Create a worktree for a repo and optionally symlink it.
+      #
+      # @param repo [String] repo identifier
+      # @param branch [String, nil]
+      # @param commit [String, nil]
+      # @param label [String, nil]
+      # @param dir [String, nil] destination path for a symlink
+      # @return [Hash] { slug:, worktree_path:, symlink_path: }
+      def checkout(repo, branch: nil, commit: nil, label: nil, dir: nil)
+        slug = Database.slugify(repo)
+        repo_obj = @database.repo(slug)
+        repo_obj.clone
+
+        worktree_path = repo_obj.create_worktree(branch: branch, commit: commit, label: label)
+        symlink_path = link_if_dir(worktree_path, dir)
+
+        { slug: slug, worktree_path: worktree_path, symlink_path: symlink_path }
+      end
+
+      # Create a new branch in a cached repo with worktree + symlink.
+      #
+      # @param repo [String] repo identifier
+      # @param name [String] new branch name
+      # @param from [String] source branch/ref (default: "main")
+      # @param dir [String, nil] destination path for the worktree symlink
+      # @return [Hash] { slug:, branch:, worktree_path:, symlink_path: }
+      def create_branch(repo, name:, from: "main", dir: nil)
+        slug = Database.slugify(repo)
+        repo_obj = @database.repo(slug)
+        repo_obj.clone
+
+        branch_name = repo_obj.create_branch(name, from: from)
+        worktree_path = repo_obj.create_worktree(branch: branch_name)
+        symlink_path = link_if_dir(worktree_path, dir)
+
+        { slug: slug, branch: branch_name, worktree_path: worktree_path, symlink_path: symlink_path }
+      end
+
+      # Remove a worktree (and optionally its symlink).
+      #
+      # @param repo [String] repo identifier
+      # @param dir [String] worktree path or symlink path to remove
+      # @return [Hash] { slug:, removed_worktree:, removed_symlink: }
+      def remove_worktree(repo, dir:)
+        slug = Database.slugify(repo)
+        repo_obj = @database.repo(slug)
+        worktree_path, removed_symlink = resolve_symlink_target(dir)
+
+        repo_obj.remove_worktree(worktree_path)
+        { slug: slug, removed_worktree: worktree_path, removed_symlink: removed_symlink }
+      end
+
+      private
+
+      def link_if_dir(worktree_path, dir)
+        return nil unless dir
+
+        Linker.link(worktree_path, File.expand_path(dir))
+      end
+
+      def resolve_symlink_target(dir)
+        if File.symlink?(dir)
+          target = File.readlink(dir)
+          Linker.unlink(dir)
+          [target, true]
+        else
+          [dir, false]
+        end
+      end
+    end
+  end
+end

data/lib/Kobold/manager/cleaning.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "set"
+
+module Kobold
+  class Manager
+    # Cleanup and purge methods.
+    module Cleaning
+      # Purge repos not referenced by a .kobold config file.
+      def clean(config_path: nil)
+        purged = config_path ? purge_unreferenced(config_path) : []
+        { purged_repos: purged }
+      end
+
+      private
+
+      def purge_unreferenced(config_path)
+        referenced = referenced_slugs_from_config(config_path)
+        purged = []
+        @database.list_repos.each_key do |slug|
+          next if referenced.include?(slug)
+
+          @database.repo(slug).purge
+          @database.unregister_repo(slug)
+          purged << { slug: slug }
+        end
+        purged
+      end
+
+      def referenced_slugs_from_config(config_path)
+        slugs = Set.new
+        collect_slugs(config_path, slugs)
+        slugs
+      end
+
+      def collect_slugs(config_path, slugs)
+        config = resolve_config(config_path)
+        config.each_dependency { |_name, dep| slugs.add(Database.slugify(dep["repo"])) }
+        base_dir = File.dirname(config.path || File.expand_path(config_path))
+        config.includes.each { |sub| collect_slugs(File.expand_path(sub, base_dir), slugs) }
+      rescue Errors::ConfigError
+        # Config not found or invalid
+      end
+    end
+  end
+end

data/lib/Kobold/manager/fetching.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kobold
+  class Manager
+    # Fetch methods for single repos and .kobold config batches.
+    module Fetching
+      # Fetch latest objects for a single repo.
+      #
+      # @param repo [String] repo identifier
+      # @return [Hash] { slug:, action: :fetched | :cloned }
+      def fetch(repo)
+        slug = Database.slugify(repo)
+        repo_obj = @database.repo(slug)
+
+        if repo_obj.cloned?
+          repo_obj.fetch
+          { slug: slug, action: :fetched }
+        else
+          repo_obj.clone
+          { slug: slug, action: :cloned }
+        end
+      end
+
+      # Fetch all repos referenced in a .kobold config file.
+      #
+      # @param config_path [String] path to the .kobold file or directory
+      # @return [Array<Hash>] one entry per dependency
+      def fetch_all(config_path: Dir.pwd)
+        config = resolve_config(config_path)
+        config.each_dependency.map do |name, dep|
+          fetch_single_dep(name, dep)
+        end
+      end
+
+      private
+
+      def fetch_single_dep(name, dep)
+        slug = Database.slugify(dep["repo"])
+        source_url = build_clone_url(dep["source"], dep["repo"])
+        @database.register_repo(slug, source_url)
+
+        repo_obj = @database.repo(slug)
+        action = fetch_or_clone(repo_obj)
+        { name: name, slug: slug, action: action }
+      end
+
+      def fetch_or_clone(repo_obj)
+        if repo_obj.cloned?
+          repo_obj.fetch
+          :fetched
+        else
+          repo_obj.clone
+          :cloned
+        end
+      end
+    end
+  end
+end

data/lib/Kobold/manager/invoking.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Kobold
+  class Manager
+    # Process .kobold config files: clone/fetch, create worktrees, symlink.
+    module Invoking
+      # Process a .kobold config file end-to-end.
+      #
+      # @param config_path [String] path to .kobold file or directory
+      # @return [Array<Hash>] one entry per dependency processed
+      def invoke(config_path: Dir.pwd)
+        config = resolve_config(config_path)
+        base_dir = config_base_dir(config, config_path)
+        results = invoke_dependencies(config, base_dir)
+        results.concat(invoke_includes(config, base_dir))
+        results
+      end
+
+      private
+
+      def invoke_dependencies(config, base_dir)
+        config.each_dependency.map do |name, dep|
+          invoke_single_dep(name, dep, base_dir)
+        end
+      end
+
+      def invoke_single_dep(name, dep, base_dir)
+        slug = Database.slugify(dep["repo"])
+        source_url = build_clone_url(dep["source"], dep["repo"])
+        @database.register_repo(slug, source_url)
+
+        repo_obj = @database.repo(slug)
+        repo_obj.clone
+
+        worktree_path = repo_obj.create_worktree(
+          branch: dep["branch"], commit: dep["commit"], label: dep["label"]
+        )
+        symlink_path = link_dep_dir(worktree_path, dep["dir"], base_dir, name: name)
+
+        { name: name, slug: slug, worktree_path: worktree_path, symlink_path: symlink_path }
+      end
+
+      def invoke_includes(config, base_dir)
+        config.includes.flat_map do |sub_path|
+          invoke(config_path: File.expand_path(sub_path, base_dir))
+        end
+      end
+
+      def link_dep_dir(worktree_path, dir, base_dir, name: nil)
+        return nil unless dir
+
+        destination = File.expand_path(dir, base_dir)
+        if dir.end_with?("/") && name
+          FileUtils.mkdir_p(destination)
+          destination = File.join(destination, name)
+        elsif dir.end_with?("/")
+          destination += "/"
+        end
+        Linker.link(worktree_path, destination)
+      end
+
+      def config_base_dir(config, config_path)
+        File.dirname(config.path || File.expand_path(config_path))
+      end
+    end
+  end
+end

data/lib/Kobold/manager/lifecycle.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Kobold
+  class Manager
+    # Dependency lifecycle: add, remove, update.
+    module Lifecycle
+      # Add a dependency to an existing .kobold config file.
+      def add(config_path:, repo:, source:, name: nil, **options)
+        name ||= repo.split("/").last
+        config = resolve_config(config_path)
+        dep = build_dep_entry(repo, source, options)
+        config.add_dependency(name, dep)
+        Config.write(config.path, config)
+
+        action = register_and_clone(repo, source)
+        { config_path: config.path, name: name, slug: Database.slugify(repo), action: action }
+      end
+
+      # Remove a dependency from a .kobold config file.
+      def remove(config_path:, dependency_name:, cleanup: false)
+        config = resolve_config(config_path)
+        dep = config.dependency(dependency_name)
+        raise Errors::DependencyNotFound, dependency_name unless dep
+
+        result = cleanup ? cleanup_dependency(dep, config) : { removed_worktree: nil, removed_symlink: false }
+        config.remove_dependency(dependency_name)
+        Config.write(config.path, config)
+        result.merge(config_path: config.path, name: dependency_name)
+      end
+
+      # Update a dependency's commit SHA to the latest on its branch.
+      def update(config_path:, dependency_name:)
+        config = resolve_config(config_path)
+        dep = config.dependency(dependency_name)
+        raise Errors::DependencyNotFound, dependency_name unless dep
+        raise Errors::ConfigError, "Dependency '#{dependency_name}' has no branch to update from" unless dep["branch"]
+
+        result = perform_update(config, dependency_name, dep)
+        Config.write(config.path, config)
+        result.merge(config_path: config.path, name: dependency_name)
+      end
+
+      # Update all dependencies with a branch specified.
+      def update_all(config_path: Dir.pwd)
+        config = resolve_config(config_path)
+        results = []
+        config.each_dependency do |name, dep|
+          next unless dep["branch"]
+
+          results << safe_update(config, name)
+        end
+        results
+      end
+
+      private
+
+      def build_dep_entry(repo, source, options)
+        dep = { "repo" => repo, "source" => source }
+        %i[branch commit label dir].each { |k| dep[k.to_s] = options[k] if options[k] }
+        dep
+      end
+
+      def register_and_clone(repo, source)
+        slug = Database.slugify(repo)
+        @database.register_repo(slug, build_clone_url(source, repo))
+        repo_obj = @database.repo(slug)
+        return :already_cached if repo_obj.cloned?
+
+        repo_obj.clone
+        :cloned
+      end
+
+      def cleanup_dependency(dep, config)
+        slug = Database.slugify(dep["repo"])
+        base_dir = File.dirname(config.path)
+        removed_symlink = cleanup_symlink(dep, base_dir)
+        removed_worktree = cleanup_worktree(dep, slug)
+        { removed_worktree: removed_worktree, removed_symlink: removed_symlink }
+      end
+
+      def cleanup_symlink(dep, base_dir)
+        return false unless dep["dir"]
+
+        remove_symlink_at(File.expand_path(dep["dir"], base_dir))
+      end
+
+      def remove_symlink_at(dest)
+        return Linker.unlink(dest) || true if File.symlink?(dest)
+        return check_nested_symlink(dest) if File.directory?(dest)
+
+        false
+      end
+
+      def check_nested_symlink(dest)
+        link = Dir.children(dest).map { |c| File.join(dest, c) }.find { |p| File.symlink?(p) }
+        return false unless link
+
+        Linker.unlink(link)
+        true
+      end
+
+      def cleanup_worktree(dep, slug)
+        repo_obj = @database.repo(slug)
+        wt = repo_obj.worktree_path_for(branch: dep["branch"], commit: dep["commit"], label: dep["label"])
+        return nil unless Dir.exist?(wt)
+
+        repo_obj.remove_worktree(wt)
+        wt
+      rescue Errors::RepoNotFound, Errors::GitError
+        nil
+      end
+
+      def perform_update(config, name, dep)
+        slug = Database.slugify(dep["repo"])
+        @database.register_repo(slug, build_clone_url(dep["source"], dep["repo"]))
+        repo_obj = @database.repo(slug)
+        repo_obj.clone
+        repo_obj.fetch
+
+        old = dep["commit"]
+        new_sha = repo_obj.resolve_branch_head(dep["branch"])
+        config.update_dependency(name, "commit", new_sha)
+        { old_commit: old, new_commit: new_sha, branch: dep["branch"] }
+      end
+
+      def safe_update(config, name)
+        update(config_path: config.path, dependency_name: name)
+      rescue Errors::GitError, Errors::RepoNotFound => e
+        { config_path: config.path, name: name, error: e.message }
+      end
+    end
+  end
+end