caruso 0.5.4

data/lib/caruso/config_manager.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+
+module Caruso
+  class ConfigManager
+    PROJECT_CONFIG_FILENAME = "caruso.json"
+    LOCAL_CONFIG_FILENAME = ".caruso.local.json"
+    SUPPORTED_IDES = ["cursor"].freeze
+    IDE_TARGET_DIRS = {
+      "cursor" => ".cursor/rules"
+    }.freeze
+
+    attr_reader :project_dir, :project_config_path, :local_config_path
+
+    def initialize(project_dir = Dir.pwd)
+      @project_dir = File.expand_path(project_dir)
+      @project_config_path = File.join(@project_dir, PROJECT_CONFIG_FILENAME)
+      @local_config_path = File.join(@project_dir, LOCAL_CONFIG_FILENAME)
+    end
+
+    def init(ide:)
+      unless SUPPORTED_IDES.include?(ide)
+        raise ArgumentError, "Unsupported IDE: #{ide}. Supported: #{SUPPORTED_IDES.join(', ')}"
+      end
+
+      if config_exists?
+        raise Error, "Caruso is already initialized in #{@project_dir}."
+      end
+
+      # Create project config (caruso.json)
+      project_config = {
+        "version" => "1.0.0",
+        "marketplaces" => {},
+        "plugins" => {}
+      }
+      save_project_config(project_config)
+
+      # Create local config (.caruso.local.json)
+      local_config = {
+        "ide" => ide,
+        "target_dir" => IDE_TARGET_DIRS[ide],
+        "installed_files" => {}
+      }
+      save_local_config(local_config)
+
+      { **project_config, **local_config }
+    end
+
+    def load
+      unless config_exists?
+        raise Error, "Caruso not initialized. Run 'caruso init --ide=cursor' first."
+      end
+
+      project_data = load_project_config
+      local_data = load_local_config
+
+      # Merge data for easier access, but keep them conceptually separate
+      project_data.merge(local_data)
+    end
+
+    def config_exists?
+      File.exist?(@project_config_path) && File.exist?(@local_config_path)
+    end
+
+    def target_dir
+      load["target_dir"]
+    end
+
+    def full_target_path
+      File.join(@project_dir, target_dir)
+    end
+
+    def ide
+      load["ide"]
+    end
+
+    # Plugin Management
+
+    def add_plugin(name, files, marketplace_name:)
+      # Update project config (Intent)
+      project_data = load_project_config
+      project_data["plugins"] ||= {}
+      project_data["plugins"][name] = {
+        "marketplace" => marketplace_name
+      }
+      save_project_config(project_data)
+
+      # Update local config (Files)
+      local_data = load_local_config
+      local_data["installed_files"] ||= {}
+      local_data["installed_files"][name] = files
+      save_local_config(local_data)
+    end
+
+    def remove_plugin(name)
+      # Get files to remove from local config
+      local_data = load_local_config
+      files = local_data.dig("installed_files", name) || []
+
+      # Remove from local config
+      if local_data["installed_files"]
+        local_data["installed_files"].delete(name)
+        save_local_config(local_data)
+      end
+
+      # Remove from project config
+      project_data = load_project_config
+      if project_data["plugins"]
+        project_data["plugins"].delete(name)
+        save_project_config(project_data)
+      end
+
+      files
+    end
+
+    def list_plugins
+      load_project_config["plugins"] || {}
+    end
+
+    def plugin_installed?(name)
+      plugins = list_plugins
+      plugins.key?(name)
+    end
+
+    def get_installed_files(name)
+      load_local_config.dig("installed_files", name) || []
+    end
+
+    # Marketplace Management
+
+    def add_marketplace(name, url, source: "git", ref: nil)
+      data = load_project_config
+      data["marketplaces"] ||= {}
+      data["marketplaces"][name] = {
+        "url" => url,
+        "source" => source,
+        "ref" => ref
+      }.compact
+      save_project_config(data)
+    end
+
+    def remove_marketplace(name)
+      data = load_project_config
+      return unless data["marketplaces"]
+
+      data["marketplaces"].delete(name)
+      save_project_config(data)
+    end
+
+    def list_marketplaces
+      load_project_config["marketplaces"] || {}
+    end
+
+    def get_marketplace_details(name)
+      load_project_config.dig("marketplaces", name)
+    end
+
+    def get_marketplace_url(name)
+      details = get_marketplace_details(name)
+      details ? details["url"] : nil
+    end
+
+    private
+
+    def load_project_config
+      return {} unless File.exist?(@project_config_path)
+      JSON.parse(File.read(@project_config_path))
+    rescue JSON::ParserError
+      {}
+    end
+
+    def save_project_config(data)
+      File.write(@project_config_path, JSON.pretty_generate(data))
+    end
+
+    def load_local_config
+      return {} unless File.exist?(@local_config_path)
+      JSON.parse(File.read(@local_config_path))
+    rescue JSON::ParserError
+      {}
+    end
+
+    def save_local_config(data)
+      File.write(@local_config_path, JSON.pretty_generate(data))
+    end
+  end
+end

data/lib/caruso/fetcher.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "json"
+require "faraday"
+require "fileutils"
+require "uri"
+require "git"
+
+module Caruso
+  class Fetcher
+    attr_reader :marketplace_uri
+
+    def initialize(marketplace_uri, marketplace_name: nil, ref: nil)
+      @marketplace_uri = marketplace_uri
+      @marketplace_name = marketplace_name
+      @ref = ref
+      @registry = MarketplaceRegistry.new
+    end
+
+    def cache_dir
+      # Cache directory based on URL for stability (name comes from marketplace.json)
+      url_based_name = extract_name_from_url(@marketplace_uri)
+      File.join(Dir.home, ".caruso", "marketplaces", url_based_name)
+    end
+
+    def fetch(plugin_name)
+      marketplace_data = load_marketplace
+      plugins = marketplace_data["plugins"] || []
+
+      plugin = plugins.find { |p| p["name"] == plugin_name }
+      unless plugin
+        available = plugins.map { |p| p["name"] }
+        raise PluginNotFoundError.new("Plugin '#{plugin_name}' not found in marketplace", available)
+      end
+
+      fetch_plugin(plugin)
+    end
+
+    def list_available_plugins
+      marketplace_data = load_marketplace
+      plugins = marketplace_data["plugins"] || []
+      plugins.map do |p|
+        {
+          name: p["name"],
+          description: p["description"],
+          version: p["version"]
+        }
+      end
+    end
+
+    def update_cache
+      return unless Dir.exist?(cache_dir)
+
+      Dir.chdir(cache_dir) do
+        git = Git.open(".")
+        if @ref
+          git.fetch("origin", @ref)
+          git.checkout(@ref)
+        end
+        git.pull("origin", "HEAD")
+      end
+
+      @registry.update_timestamp(@marketplace_name)
+    rescue => e
+      handle_git_error(e)
+    end
+
+    def clone_git_repo(source_config)
+      url = source_config["url"] || source_config["repo"]
+      url = "https://github.com/#{url}.git" if source_config["source"] == "github" && !url.match?(/\Ahttps?:/)
+
+      repo_name = URI.parse(url).path.split("/").last.sub(".git", "")
+      target_path = cache_dir
+
+      unless Dir.exist?(target_path)
+        # Clone the repository
+        FileUtils.mkdir_p(File.dirname(target_path))
+        Git.clone(url, target_path)
+        checkout_ref if @ref
+
+        # Add to registry
+        source_type = source_config["source"] || "git"
+        @registry.add_marketplace(@marketplace_name, url, target_path, ref: @ref, source: source_type)
+      end
+
+      target_path
+    rescue StandardError => e
+      handle_git_error(e)
+      nil
+    end
+
+    def extract_marketplace_name
+      marketplace_data = load_marketplace
+      name = marketplace_data["name"]
+
+      unless name
+        raise Caruso::Error, "Invalid marketplace: marketplace.json missing required 'name' field"
+      end
+
+      name
+    end
+
+    private
+
+    def load_marketplace
+      if local_path?
+        # If marketplace_uri is a directory, find marketplace.json in it
+        if File.directory?(@marketplace_uri)
+          json_path = File.join(@marketplace_uri, ".claude-plugin", "marketplace.json")
+          json_path = File.join(@marketplace_uri, "marketplace.json") unless File.exist?(json_path)
+
+          unless File.exist?(json_path)
+            raise Caruso::Error, "Could not find marketplace.json in #{@marketplace_uri}"
+          end
+
+          @marketplace_uri = json_path
+        end
+
+        @base_dir = File.dirname(@marketplace_uri)
+        # Heuristic: if we are in .claude-plugin, the real root is one level up
+        if File.basename(@base_dir) == ".claude-plugin"
+          @base_dir = File.dirname(@base_dir)
+        end
+
+        JSON.parse(File.read(@marketplace_uri))
+      elsif github_repo?
+        # Clone repo and read marketplace.json from it
+        repo_path = clone_git_repo("url" => @marketplace_uri, "source" => "github")
+        # Try standard locations
+        json_path = File.join(repo_path, ".claude-plugin", "marketplace.json")
+        json_path = File.join(repo_path, "marketplace.json") unless File.exist?(json_path)
+
+        unless File.exist?(json_path)
+          raise "Could not find marketplace.json in #{@marketplace_uri}"
+        end
+
+        # Update marketplace_uri to point to the local file so relative paths work
+        @marketplace_uri = json_path
+        @base_dir = repo_path # Base dir is the repo root, regardless of where json is
+
+        JSON.parse(File.read(json_path))
+      else
+        response = Faraday.get(@marketplace_uri)
+        JSON.parse(response.body)
+      end
+    end
+
+    def github_repo?
+      @marketplace_uri.match?(%r{\Ahttps://github\.com/[^/]+/[^/]+}) ||
+        @marketplace_uri.match?(%r{\A[^/]+/[^/]+\z}) # owner/repo format
+    end
+
+    def fetch_plugin(plugin)
+      source = plugin["source"]
+      plugin_path = resolve_plugin_path(source)
+      return [] unless plugin_path && Dir.exist?(plugin_path)
+
+      # Start with default directories
+      files = find_steering_files(plugin_path)
+
+      # Add custom paths if specified (they supplement defaults)
+      files += find_custom_component_files(plugin_path, plugin["commands"]) if plugin["commands"]
+      files += find_custom_component_files(plugin_path, plugin["agents"]) if plugin["agents"]
+      files += find_custom_component_files(plugin_path, plugin["skills"]) if plugin["skills"]
+
+      files.uniq
+    end
+
+    def resolve_plugin_path(source)
+      if source.is_a?(Hash) && %w[git github].include?(source["source"])
+        clone_git_repo(source)
+      elsif local_path? && source.is_a?(String) && (source.start_with?(".") || source.start_with?("/"))
+        if source.start_with?("/")
+          source
+        else
+          File.expand_path(source, @base_dir)
+        end
+      elsif source.is_a?(String) && source.match?(/\Ahttps?:/)
+        # Assume it's a git URL if it ends in .git or we treat it as such
+        clone_git_repo("url" => source)
+      else
+        # Fallback or error
+        puts "Warning: Could not resolve source for plugin: #{source}"
+        nil
+      end
+    end
+
+    def find_steering_files(plugin_path)
+      Dir.glob(File.join(plugin_path, "{commands,agents,skills}/**/*.md")).reject do |file|
+        basename = File.basename(file).downcase
+        ["readme.md", "license.md"].include?(basename)
+      end
+    end
+
+    def find_custom_component_files(plugin_path, paths)
+      # Handle both string and array formats
+      paths = [paths] if paths.is_a?(String)
+      return [] unless paths.is_a?(Array)
+
+      files = []
+      paths.each do |path|
+        # Resolve the path relative to plugin_path
+        full_path = File.expand_path(path, plugin_path)
+
+        # Handle both files and directories
+        if File.file?(full_path) && full_path.end_with?(".md")
+          basename = File.basename(full_path).downcase
+          files << full_path unless ["readme.md", "license.md"].include?(basename)
+        elsif Dir.exist?(full_path)
+          # Find all .md files in this directory
+          Dir.glob(File.join(full_path, "**/*.md")).each do |file|
+            basename = File.basename(file).downcase
+            files << file unless ["readme.md", "license.md"].include?(basename)
+          end
+        end
+      end
+      files
+    end
+
+    def local_path?
+      !@marketplace_uri.match?(/\Ahttps?:/)
+    end
+
+    def handle_git_error(error)
+      msg = error.message.to_s
+      if msg.include?("Permission denied") ||
+         msg.include?("publickey") ||
+         msg.include?("Could not read from remote")
+        raise Caruso::Error, "SSH authentication failed while accessing marketplace.\n" \
+                             "Please ensure your SSH keys are configured for #{@marketplace_uri}"
+      end
+      raise error
+    end
+
+    def checkout_ref
+      return unless @ref
+
+      Dir.chdir(cache_dir) do
+        git = Git.open(".")
+        git.checkout(@ref)
+      end
+    end
+
+    def extract_name_from_url(url)
+      url.split("/").last.sub(".git", "")
+    end
+  end
+end

data/lib/caruso/marketplace_registry.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Caruso
+  class MarketplaceRegistry
+    REGISTRY_FILENAME = "known_marketplaces.json"
+
+    def initialize
+      @registry_path = File.join(Dir.home, ".caruso", REGISTRY_FILENAME)
+    end
+
+    # Enhancement #1: Add source type tracking
+    def add_marketplace(name, url, install_location, ref: nil, source: "git")
+      data = load_registry
+      data[name] = {
+        "source" => source,  # github, git, url, local, directory
+        "url" => url,
+        "install_location" => install_location,
+        "last_updated" => Time.now.iso8601,
+        "ref" => ref
+      }.compact
+      save_registry(data)
+    end
+
+    def get_marketplace(name)
+      data = load_registry
+      data[name]
+    end
+
+    def update_timestamp(name)
+      data = load_registry
+      return unless data[name]
+
+      data[name]["last_updated"] = Time.now.iso8601
+      save_registry(data)
+    end
+
+    def list_marketplaces
+      load_registry
+    end
+
+    def remove_marketplace(name)
+      data = load_registry
+      data.delete(name)
+      save_registry(data)
+    end
+
+    private
+
+    # Enhancement #3: Schema validation
+    def validate_marketplace_entry(entry)
+      required = ["url", "install_location", "last_updated"]
+      missing = required - entry.keys
+
+      unless missing.empty?
+        raise Caruso::Error, "Invalid marketplace entry: missing #{missing.join(', ')}"
+      end
+
+      # Validate timestamp format
+      Time.iso8601(entry["last_updated"])
+    rescue ArgumentError
+      raise Caruso::Error, "Invalid timestamp format in marketplace entry"
+    end
+
+    # Enhancement #4: Registry corruption handling
+    def load_registry
+      return {} unless File.exist?(@registry_path)
+
+      data = JSON.parse(File.read(@registry_path))
+
+      # Validate each entry
+      data.each do |name, entry|
+        validate_marketplace_entry(entry)
+      end
+
+      data
+    rescue JSON::ParserError => e
+      handle_corrupted_registry(e)
+      {}
+    rescue Caruso::Error => e
+      warn "Warning: Invalid marketplace entry: #{e.message}"
+      warn "Continuing with partial registry data."
+      {}
+    end
+
+    def handle_corrupted_registry(error)
+      corrupted_path = "#{@registry_path}.corrupted.#{Time.now.to_i}"
+      FileUtils.cp(@registry_path, corrupted_path)
+
+      warn "Marketplace registry corrupted. Backup saved to: #{corrupted_path}"
+      warn "Error: #{error.message}"
+      warn "Starting with empty registry."
+    end
+
+    def save_registry(data)
+      FileUtils.mkdir_p(File.dirname(@registry_path))
+      File.write(@registry_path, JSON.pretty_generate(data))
+    end
+  end
+end

data/lib/caruso/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Caruso
+  VERSION = "0.5.4"
+end

data/lib/caruso.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "caruso/version"
+require_relative "caruso/config_manager"
+require_relative "caruso/fetcher"
+require_relative "caruso/adapter"
+require_relative "caruso/marketplace_registry"
+
+require_relative "caruso/cli"
+
+module Caruso
+  class Error < StandardError; end
+
+  class PluginNotFoundError < Error
+    attr_reader :available_plugins
+
+    def initialize(message, available_plugins = [])
+      super(message)
+      @available_plugins = available_plugins
+    end
+  end
+end