caruso 0.6.2 → 0.7.0

data/lib/caruso/fetcher.rb

@@ -180,17 +180,41 @@ module Caruso
 
       return [] unless SafeDir.exist?(plugin_path)
 
-      # Start with default directories
-      files = find_steering_files(plugin_path)
+      # Merge marketplace entry with plugin.json (marketplace takes precedence)
+      merged_plugin_data = merge_with_plugin_json(plugin, 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 = find_steering_files(plugin_path, merged_plugin_data)
 
       files.uniq
     end
 
+    # Read plugin.json and merge with marketplace entry.
+    # Marketplace fields override plugin.json fields for component paths.
+    def merge_with_plugin_json(marketplace_entry, plugin_path)
+      plugin_json_path = File.join(plugin_path, ".claude-plugin", "plugin.json")
+      return marketplace_entry unless File.exist?(plugin_json_path)
+
+      begin
+        plugin_data = JSON.parse(SafeFile.read(plugin_json_path))
+      rescue JSON::ParserError => e
+        puts "Warning: Could not parse plugin.json: #{e.message}"
+        return marketplace_entry
+      end
+
+      component_fields = %w[commands agents skills hooks mcpServers]
+      merged = marketplace_entry.dup
+
+      component_fields.each do |field|
+        # Only use plugin.json value if marketplace entry doesn't specify this field
+        next if merged.key?(field)
+        next unless plugin_data.key?(field)
+
+        merged[field] = plugin_data[field]
+      end
+
+      merged
+    end
+
     def resolve_plugin_path(source)
       if source.is_a?(Hash) && %w[git github].include?(source["source"])
         clone_git_repo(source)
@@ -210,18 +234,47 @@ module Caruso
       end
     end
 
-    def find_steering_files(plugin_path)
-      # Validate plugin_path before using it in glob
-      # This is safe because plugin_path comes from resolve_plugin_path which returns trusted paths
-      # (either from cache_dir which is under ~/.caruso, or validated local paths)
-      glob_pattern = PathSanitizer.safe_join(plugin_path, "{commands,agents,skills}", "**", "*.md")
+    # Find all steering files based on default locations and manifest overrides
+    # RETURNS: unique list of absolute file paths to fetch
+    def find_steering_files(plugin_path, plugin_data = nil)
+      files = []
+
+      # 1. ALWAYS scan default directories (Additive Strategy)
+      files += glob_plugin_files(plugin_path, "commands", "**", "*.md")
+      files += glob_plugin_files(plugin_path, "agents", "**", "*.md")
+
+      # For skills, we want recursive default scan if 'skills/' exists
+      # But careful: if we scan default 'skills' recursively here, and then scan strict paths from manifest...
+      # Duplicate handling is fine via uniq.
+      default_skills_path = File.join(plugin_path, "skills")
+      if SafeDir.exist?(default_skills_path)
+        files += find_recursive_component_files(plugin_path, "skills")
+      end
 
-      SafeDir.glob(glob_pattern, base_dir: plugin_path).reject do |file|
+      # 2. Add manifest-defined paths (if present)
+      if plugin_data
+        files += find_custom_component_files(plugin_path, plugin_data["commands"]) if plugin_data["commands"]
+        files += find_custom_component_files(plugin_path, plugin_data["agents"]) if plugin_data["agents"]
+        files += find_recursive_component_files(plugin_path, plugin_data["skills"]) if plugin_data["skills"]
+      end
+
+      # 3. Detect hooks files
+      files += find_hooks_files(plugin_path, plugin_data)
+
+      # Filter out noise
+      files.uniq.reject do |file|
         basename = File.basename(file).downcase
-        ["readme.md", "license.md"].include?(basename)
+        ["readme.md", "license.md", "plugin.json"].include?(basename) || File.directory?(file)
       end
     end
 
+    # Helper to glob files safely
+    def glob_plugin_files(plugin_path, *parts)
+      pattern = PathSanitizer.safe_join(plugin_path, *parts)
+      SafeDir.glob(pattern, base_dir: plugin_path)
+    end
+
+    # For Commands/Agents: typically just markdown files, flat or shallow
     def find_custom_component_files(plugin_path, paths)
       # Handle both string and array formats
       paths = [paths] if paths.is_a?(String)
@@ -229,31 +282,86 @@ module Caruso
 
       files = []
       paths.each do |path|
-        # Resolve and sanitize the path relative to plugin_path
-        # This ensures the path stays within plugin_path boundaries
-        begin
-          full_path = PathSanitizer.sanitize_path(File.expand_path(path, plugin_path), base_dir: plugin_path)
-        rescue PathSanitizer::PathTraversalError => e
-          warn "Skipping path outside plugin directory '#{path}': #{e.message}"
-          next
-        end
+        full_path = resolve_safe_path(plugin_path, path)
+        next unless full_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)
+          files << full_path
         elsif SafeDir.exist?(full_path, base_dir: plugin_path)
-          # Find all .md files in this directory using safe_join
+          # Find all .md files in this directory
           glob_pattern = PathSanitizer.safe_join(full_path, "**", "*.md")
-          SafeDir.glob(glob_pattern, base_dir: plugin_path).each do |file|
-            basename = File.basename(file).downcase
-            files << file unless ["readme.md", "license.md"].include?(basename)
-          end
+          files += SafeDir.glob(glob_pattern, base_dir: plugin_path)
+        end
+      end
+      files
+    end
+
+    # For SKILLS: Recursive fetch of EVERYTHING (scripts, assets, md)
+    def find_recursive_component_files(plugin_path, paths)
+      paths = [paths] if paths.is_a?(String)
+      return [] unless paths.is_a?(Array)
+
+      files = []
+      paths.each do |path|
+        full_path = resolve_safe_path(plugin_path, path)
+        next unless full_path
+
+        if File.file?(full_path)
+          files << full_path
+        elsif SafeDir.exist?(full_path, base_dir: plugin_path)
+          # Grab EVERYTHING recursively
+          glob_pattern = PathSanitizer.safe_join(full_path, "**", "*")
+          files += SafeDir.glob(glob_pattern, base_dir: plugin_path)
         end
       end
       files
     end
 
+    def find_hooks_files(plugin_path, plugin_data)
+      files = []
+
+      # Default hooks/ directory
+      default_hooks = File.join(plugin_path, "hooks", "hooks.json")
+      files << default_hooks if File.exist?(default_hooks)
+
+      # Custom hooks from manifest (inline config or path-based)
+      return files unless plugin_data&.key?("hooks")
+
+      hooks_value = plugin_data["hooks"]
+      if hooks_value.is_a?(Hash)
+        inline_path = File.join(plugin_path, ".caruso_inline_hooks.json")
+        File.write(inline_path, JSON.pretty_generate(hooks_value))
+        files << inline_path
+      else
+        files += find_custom_hooks_paths(plugin_path, hooks_value)
+      end
+
+      files
+    end
+
+    def find_custom_hooks_paths(plugin_path, hooks_value)
+      files = []
+      [hooks_value].flatten.each do |path|
+        full_path = resolve_safe_path(plugin_path, path)
+        next unless full_path
+
+        if File.file?(full_path) && File.basename(full_path) == "hooks.json"
+          files << full_path
+        elsif SafeDir.exist?(full_path, base_dir: plugin_path)
+          candidate = File.join(full_path, "hooks.json")
+          files << candidate if File.exist?(candidate)
+        end
+      end
+      files
+    end
+
+    def resolve_safe_path(plugin_path, relative_path)
+      PathSanitizer.sanitize_path(File.expand_path(relative_path, plugin_path), base_dir: plugin_path)
+    rescue PathSanitizer::PathTraversalError => e
+      warn "Skipping path outside plugin directory '#{relative_path}': #{e.message}"
+      nil
+    end
+
     def local_path?
       !@marketplace_uri.match?(/\Ahttps?:/)
     end

data/lib/caruso/remover.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "marketplace_registry"
 
 module Caruso
@@ -11,12 +12,12 @@ module Caruso
     end
 
     def remove_marketplace(name)
-      # 1. Remove from config and get associated plugin files
-      # This updates both project config (plugins) and local config (files)
-      files_to_remove = config_manager.remove_marketplace_with_plugins(name)
+      # 1. Remove from config and get associated plugin files/hooks
+      result = config_manager.remove_marketplace_with_plugins(name)
 
-      # 2. Delete the actual files
-      delete_files(files_to_remove)
+      # 2. Delete the actual files and remove hooks
+      delete_files(result[:files])
+      remove_plugin_hooks(result[:hooks]) if result[:hooks] && !result[:hooks].empty?
 
       # 3. Clean up registry cache
       remove_from_registry(name)
@@ -24,21 +25,80 @@ module Caruso
 
     def remove_plugin(name)
       # 1. Remove from config
-      files_to_remove = config_manager.remove_plugin(name)
+      result = config_manager.remove_plugin(name)
 
-      # 2. Delete files
-      delete_files(files_to_remove)
+      # 2. Delete files and remove hooks
+      delete_files(result[:files])
+      remove_plugin_hooks(result[:hooks]) if result[:hooks] && !result[:hooks].empty?
     end
 
     private
 
     def delete_files(files)
-      files.each do |file|
+      # Skip hooks.json — it's a merged file handled separately by remove_plugin_hooks
+      files.reject { |f| File.basename(f) == "hooks.json" && f.include?(".cursor") }.each do |file|
         full_path = File.join(config_manager.project_dir, file)
-        if File.exist?(full_path)
-          File.delete(full_path)
-          puts "  Deleted #{file}"
-        end
+        next unless File.exist?(full_path)
+
+        File.delete(full_path)
+        puts "  Deleted #{file}"
+        cleanup_empty_parents(full_path)
+      end
+    end
+
+    # Walk up from a deleted file's parent, removing empty directories
+    # until we hit .cursor/ itself or a non-empty directory.
+    def cleanup_empty_parents(file_path)
+      cursor_dir = File.join(config_manager.project_dir, ".cursor")
+      dir = File.dirname(file_path)
+
+      while dir != cursor_dir && dir.start_with?(cursor_dir)
+        break unless Dir.exist?(dir) && Dir.empty?(dir)
+
+        Dir.rmdir(dir)
+        dir = File.dirname(dir)
+      end
+    end
+
+    # Remove specific hook entries from .cursor/hooks.json using tracked metadata.
+    # installed_hooks is a hash: { "event_name" => [{ "command" => "..." }, ...] }
+    def remove_plugin_hooks(installed_hooks)
+      hooks_path = File.join(config_manager.project_dir, ".cursor", "hooks.json")
+      return unless File.exist?(hooks_path)
+
+      begin
+        data = JSON.parse(File.read(hooks_path))
+        hooks = data["hooks"] || {}
+      rescue JSON::ParserError
+        return
+      end
+
+      return unless remove_tracked_commands(hooks, installed_hooks)
+
+      hooks.reject! { |_, entries| entries.empty? }
+      write_or_delete_hooks(hooks_path, hooks)
+    end
+
+    def remove_tracked_commands(hooks, installed_hooks)
+      changed = false
+      installed_hooks.each do |event, entries|
+        next unless hooks[event]
+
+        commands_to_remove = entries.map { |e| e["command"] }.compact.to_set
+        before_count = hooks[event].length
+        hooks[event].reject! { |entry| commands_to_remove.include?(entry["command"]) }
+        changed = true if hooks[event].length != before_count
+      end
+      changed
+    end
+
+    def write_or_delete_hooks(hooks_path, hooks)
+      if hooks.empty?
+        File.delete(hooks_path)
+        puts "  Deleted .cursor/hooks.json (empty after plugin removal)"
+      else
+        File.write(hooks_path, JSON.pretty_generate({ "version" => 1, "hooks" => hooks }))
+        puts "  Updated .cursor/hooks.json (removed plugin hooks)"
       end
     end
 

data/lib/caruso/version.rb

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

data/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "identify-missing-features",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}