caruso 0.6.2 → 0.7.0

data/lib/caruso/adapters/hook_adapter.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "base"
+
+module Caruso
+  module Adapters
+    class HookAdapter < Base
+      # Claude Code events that map to Cursor events.
+      # Each CC event maps to a single Cursor event name.
+      # Matchers are lost in translation (Cursor has no matcher concept).
+      EVENT_MAP = {
+        "PreToolUse" => "beforeShellExecution",
+        "PostToolUse" => "afterShellExecution",
+        "UserPromptSubmit" => "beforeSubmitPrompt",
+        "Stop" => "stop"
+      }.freeze
+
+      # PostToolUse with Write|Edit matchers should map to afterFileEdit instead.
+      # We detect this via the matcher pattern.
+      FILE_EDIT_MATCHERS = /\A(Write|Edit|Write\|Edit|Edit\|Write|Notebook.*)\z/i
+
+      # Events that have no Cursor equivalent and must be skipped.
+      UNSUPPORTED_EVENTS = %w[
+        SessionStart
+        SessionEnd
+        SubagentStop
+        PreCompact
+        Notification
+        PermissionRequest
+      ].freeze
+
+      # After adapt(), contains the translated hook commands keyed by event.
+      # Used by callers to track which hooks were installed for clean uninstall.
+      attr_reader :translated_hooks
+
+      def adapt
+        @translated_hooks = {}
+
+        hooks_file = find_hooks_file
+        return [] unless hooks_file
+
+        plugin_hooks = parse_hooks_file(hooks_file)
+        return [] if plugin_hooks.nil? || plugin_hooks.empty?
+
+        cursor_hooks = translate_hooks(plugin_hooks)
+        return [] if cursor_hooks.empty?
+
+        # Copy any referenced scripts
+        copied_scripts = copy_hook_scripts(cursor_hooks, hooks_file)
+
+        # Merge into existing .cursor/hooks.json
+        merge_hooks(cursor_hooks)
+
+        # Store for tracking
+        @translated_hooks = cursor_hooks
+
+        # Return list of created/modified files for tracking
+        created = [".cursor/hooks.json"]
+        created += copied_scripts
+        created
+      end
+
+      private
+
+      def find_hooks_file
+        # files array contains the hooks.json path passed in by the Dispatcher.
+        # Also matches .caruso_inline_hooks.json written by Fetcher for inline plugin.json hooks.
+        files.find { |f| File.basename(f) =~ /hooks\.json\z/ }
+      end
+
+      def parse_hooks_file(hooks_file)
+        content = SafeFile.read(hooks_file)
+        data = JSON.parse(content)
+        data["hooks"]
+      rescue JSON::ParserError => e
+        puts "Warning: Could not parse hooks.json: #{e.message}"
+        nil
+      end
+
+      def translate_hooks(plugin_hooks)
+        cursor_hooks = {}
+        skipped_events = []
+        skipped_prompts = 0
+
+        plugin_hooks.each do |event_name, matchers|
+          if UNSUPPORTED_EVENTS.include?(event_name)
+            skipped_events << event_name
+            next
+          end
+
+          result = translate_event_hooks(event_name, matchers)
+          result[:hooks].each { |event, entries| (cursor_hooks[event] ||= []).concat(entries) }
+          skipped_prompts += result[:skipped_prompts]
+        end
+
+        warn_skipped(skipped_events, skipped_prompts)
+        cursor_hooks
+      end
+
+      def translate_event_hooks(event_name, matchers)
+        hooks = {}
+        skipped = 0
+
+        matchers.each do |matcher_entry|
+          matcher = matcher_entry["matcher"]
+          (matcher_entry["hooks"] || []).each do |hook|
+            if hook["type"] == "prompt"
+              skipped += 1
+              next
+            end
+
+            command = hook["command"]
+            next unless command
+
+            cursor_event = resolve_cursor_event(event_name, matcher)
+            cursor_hook = { "command" => command }
+            cursor_hook["timeout"] = hook["timeout"] if hook["timeout"]
+            (hooks[cursor_event] ||= []) << cursor_hook
+          end
+        end
+
+        { hooks: hooks, skipped_prompts: skipped }
+      end
+
+      def warn_skipped(skipped_events, skipped_prompts)
+        if skipped_events.any?
+          unique_skipped = skipped_events.uniq
+          puts "Skipping #{unique_skipped.size} unsupported hook event(s): #{unique_skipped.join(', ')}"
+          puts "  (Cursor has no equivalent for these Claude Code lifecycle events)"
+        end
+
+        return unless skipped_prompts.positive?
+
+        puts "Skipping #{skipped_prompts} prompt-based hook(s): Cursor does not support LLM evaluation in hooks"
+      end
+
+      def resolve_cursor_event(cc_event, matcher)
+        # PostToolUse with file-related matchers maps to afterFileEdit
+        if cc_event == "PostToolUse" && matcher && FILE_EDIT_MATCHERS.match?(matcher)
+          return "afterFileEdit"
+        end
+
+        EVENT_MAP[cc_event] || "afterShellExecution"
+      end
+
+      def rewrite_script_path(command)
+        plugin_script_dir = File.join("hooks", "caruso", marketplace_name, plugin_name)
+        command.gsub("${CLAUDE_PLUGIN_ROOT}", plugin_script_dir)
+      end
+
+      def plugin_root_from_hooks_file(hooks_file)
+        # ${CLAUDE_PLUGIN_ROOT} refers to the plugin root directory.
+        # hooks.json is typically at <plugin_root>/hooks/hooks.json,
+        # so the plugin root is the parent of the hooks/ directory.
+        hooks_dir = File.dirname(hooks_file)
+        if File.basename(hooks_dir) == "hooks"
+          File.dirname(hooks_dir)
+        else
+          hooks_dir
+        end
+      end
+
+      def copy_hook_scripts(cursor_hooks, hooks_file)
+        plugin_root = plugin_root_from_hooks_file(hooks_file)
+
+        cursor_hooks.each_value.flat_map do |hook_entries|
+          hook_entries.filter_map { |hook| copy_single_script(hook, plugin_root) }
+        end
+      end
+
+      def copy_single_script(hook, plugin_root)
+        command = hook["command"]
+        return unless command&.include?("${CLAUDE_PLUGIN_ROOT}")
+
+        relative_path = command.sub("${CLAUDE_PLUGIN_ROOT}/", "")
+        source_path = File.join(plugin_root, relative_path)
+        return unless File.exist?(source_path)
+
+        target_path = File.join(".cursor", "hooks", "caruso", marketplace_name, plugin_name, relative_path)
+        FileUtils.mkdir_p(File.dirname(target_path))
+        FileUtils.cp(source_path, target_path)
+        File.chmod(0o755, target_path)
+        puts "Copied hook script: #{target_path}"
+
+        hook["command"] = rewrite_script_path(command)
+        target_path
+      end
+
+      def merge_hooks(new_hooks)
+        hooks_path = File.join(".cursor", "hooks.json")
+        existing = read_existing_hooks(hooks_path)
+
+        # Merge: append new hook entries to existing event arrays
+        new_hooks.each do |event, entries|
+          existing[event] ||= []
+          entries.each do |entry|
+            # Deduplicate: don't add if an identical command already exists
+            unless existing[event].any? { |e| e["command"] == entry["command"] }
+              existing[event] << entry
+            end
+          end
+        end
+
+        FileUtils.mkdir_p(".cursor")
+        File.write(hooks_path, JSON.pretty_generate({ "version" => 1, "hooks" => existing }))
+        puts "Merged hooks into #{hooks_path}"
+      end
+
+      def read_existing_hooks(hooks_path)
+        return {} unless File.exist?(hooks_path)
+
+        data = JSON.parse(File.read(hooks_path))
+        data["hooks"] || {}
+      rescue JSON::ParserError
+        puts "Warning: Existing hooks.json is malformed, starting fresh"
+        {}
+      end
+    end
+  end
+end

data/lib/caruso/adapters/markdown_adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Caruso
+  module Adapters
+    class MarkdownAdapter < Base
+      def adapt
+        created_files = []
+        files.each do |file_path|
+          content = SafeFile.read(file_path)
+          adapted_content = inject_metadata(content, file_path)
+
+          extension = agent == :cursor ? ".mdc" : ".md"
+          created_file = save_file(file_path, adapted_content, extension: extension)
+
+          created_files << created_file
+        end
+        created_files
+      end
+    end
+  end
+end

data/lib/caruso/adapters/skill_adapter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Caruso
+  module Adapters
+    class SkillAdapter < Base
+      def adapt
+        skill_file = files.find { |f| File.basename(f).casecmp("skill.md").zero? }
+        return [] unless skill_file
+
+        skill_root = File.dirname(skill_file)
+        skill_name = File.basename(skill_root)
+        other_files = files - [skill_file]
+
+        [adapt_skill(skill_file, skill_name)] + copy_assets(other_files, skill_root, skill_name)
+      end
+
+      private
+
+      def adapt_skill(skill_file, skill_name)
+        script_location = ".cursor/scripts/caruso/#{marketplace_name}/#{plugin_name}/#{skill_name}/"
+        content = SafeFile.read(skill_file)
+        adapted_content = inject_skill_metadata(content, skill_file, script_location)
+        extension = agent == :cursor ? ".mdc" : ".md"
+        save_file(skill_file, adapted_content, extension: extension)
+      end
+
+      def inject_skill_metadata(content, file_path, script_location)
+        # Inject script location into description
+        hint = "Scripts located at: #{script_location}"
+
+        if content.match?(/\A---\s*\n.*?\n---\s*\n/m)
+          # Update existing frontmatter
+          content.sub!(/^description: (.*)$/, "description: \\1. #{hint}")
+          ensure_cursor_globs(content)
+        else
+          # Create new frontmatter with hint
+          create_skill_frontmatter(file_path, hint) + content
+        end
+      end
+
+      def create_skill_frontmatter(file_path, hint)
+        filename = File.basename(file_path)
+        <<~YAML
+          ---
+          description: Imported skill from #{filename}. #{hint}
+          globs: []
+          alwaysApply: false
+          ---
+        YAML
+      end
+
+      def copy_assets(asset_files, skill_root, skill_name)
+        asset_files.map do |file_path|
+          relative_path = file_path.sub("#{skill_root}/", "")
+          save_script(file_path, skill_name, relative_path)
+        end
+      end
+
+      def save_script(source_path, skill_name, relative_sub_path)
+        # Construct target path in .cursor/scripts
+        # .cursor/scripts/caruso/<marketplace>/<plugin>/<skill_name>/<relative_sub_path>
+
+        scripts_root = File.join(target_dir, "..", "scripts", "caruso", marketplace_name, plugin_name, skill_name)
+        # NOTE: target_dir passed to adapter is usually .cursor/rules.
+        # So .. -> .cursor -> scripts
+
+        target_path = File.join(scripts_root, relative_sub_path)
+        output_dir = File.dirname(target_path)
+
+        FileUtils.mkdir_p(output_dir)
+        FileUtils.cp(source_path, target_path)
+
+        # Make executable
+        File.chmod(0o755, target_path)
+
+        puts "Saved script: #{target_path}"
+
+        # Return relative path for tracking/reporting
+        # We start from .cursor (parent of target_dir) ideally?
+        # Or just return the absolute path for now?
+        target_path
+      end
+    end
+  end
+end

data/lib/caruso/cli.rb

@@ -227,12 +227,21 @@ module Caruso
       )
       created_filenames = adapter.adapt
 
-      # Convert filenames to relative paths from project root
-      created_files = created_filenames.map { |f| File.join(config_manager.target_dir, f) }
+      # Convert filenames to project-relative paths.
+      # Paths already starting with .cursor/ (commands, hooks) are already project-relative.
+      # Others (rules from SkillAdapter/MarkdownAdapter) are relative to target_dir.
+      created_files = created_filenames.map do |f|
+        if f.start_with?(".cursor/") || File.absolute_path?(f)
+          f
+        else
+          File.join(config_manager.target_dir, f)
+        end
+      end
 
       # Use composite key for uniqueness
       plugin_key = "#{plugin_name}@#{marketplace_name}"
-      config_manager.add_plugin(plugin_key, created_files, marketplace_name: marketplace_name)
+      config_manager.add_plugin(plugin_key, created_files, marketplace_name: marketplace_name,
+                                                           hooks: adapter.installed_hooks)
       puts "Installed #{plugin_name}!"
     end
 
@@ -455,8 +464,14 @@ module Caruso
       )
       created_filenames = adapter.adapt
 
-      # Convert filenames to relative paths from project root
-      created_files = created_filenames.map { |f| File.join(config_manager.target_dir, f) }
+      # Convert filenames to project-relative paths (same logic as install)
+      created_files = created_filenames.map do |f|
+        if f.start_with?(".cursor/") || File.absolute_path?(f)
+          f
+        else
+          File.join(config_manager.target_dir, f)
+        end
+      end
 
       # Cleanup: Delete files that are no longer present
       old_files = config_manager.get_installed_files(plugin_key)
@@ -470,7 +485,8 @@ module Caruso
       end
 
       # Update plugin in config
-      config_manager.add_plugin(plugin_key, created_files, marketplace_name: marketplace_name)
+      config_manager.add_plugin(plugin_key, created_files, marketplace_name: marketplace_name,
+                                                           hooks: adapter.installed_hooks)
     end
 
     def load_config

data/lib/caruso/config_manager.rb

@@ -54,11 +54,7 @@ module Caruso
         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)
+      load_project_config.merge(load_local_config)
     end
 
     def config_exists?
@@ -77,9 +73,7 @@ module Caruso
       load["ide"]
     end
 
-    # Plugin Management
-
-    def add_plugin(name, files, marketplace_name:)
+    def add_plugin(name, files, marketplace_name:, hooks: {})
       # Update project config (Intent)
       project_data = load_project_config
       project_data["plugins"] ||= {}
@@ -88,23 +82,32 @@ module Caruso
       }
       save_project_config(project_data)
 
-      # Update local config (Files)
+      # Update local config (Files and Hooks)
       local_data = load_local_config
       local_data["installed_files"] ||= {}
       local_data["installed_files"][name] = files
+
+      # Track installed hook commands for clean uninstall
+      local_data["installed_hooks"] ||= {}
+      if hooks.empty?
+        local_data["installed_hooks"].delete(name)
+      else
+        local_data["installed_hooks"][name] = hooks
+      end
+
       save_local_config(local_data)
     end
 
     def remove_plugin(name)
-      # Get files to remove from local config
+      # Get files and hooks to remove from local config
       local_data = load_local_config
       files = local_data.dig("installed_files", name) || []
+      hooks = local_data.dig("installed_hooks", name) || {}
 
       # Remove from local config
-      if local_data["installed_files"]
-        local_data["installed_files"].delete(name)
-        save_local_config(local_data)
-      end
+      local_data["installed_files"]&.delete(name)
+      local_data["installed_hooks"]&.delete(name)
+      save_local_config(local_data)
 
       # Remove from project config
       project_data = load_project_config
@@ -113,7 +116,7 @@ module Caruso
         save_project_config(project_data)
       end
 
-      files
+      { files: files, hooks: hooks }
     end
 
     def list_plugins
@@ -121,15 +124,16 @@ module Caruso
     end
 
     def plugin_installed?(name)
-      plugins = list_plugins
-      plugins.key?(name)
+      list_plugins.key?(name)
     end
 
     def get_installed_files(name)
       load_local_config.dig("installed_files", name) || []
     end
 
-    # Marketplace Management
+    def get_installed_hooks(name)
+      load_local_config.dig("installed_hooks", name) || {}
+    end
 
     def add_marketplace(name, url, source: "git", ref: nil)
       data = load_project_config
@@ -151,20 +155,23 @@ module Caruso
     end
 
     def remove_marketplace_with_plugins(marketplace_name)
-      files_to_remove = []
+      result = { files: [], hooks: {} }
 
       # Find and remove all plugins associated with this marketplace
       installed_plugins = list_plugins
       installed_plugins.each do |plugin_key, details|
-        if details["marketplace"] == marketplace_name
-          files_to_remove.concat(remove_plugin(plugin_key))
-        end
+        next unless details["marketplace"] == marketplace_name
+
+        plugin_result = remove_plugin(plugin_key)
+        result[:files].concat(plugin_result[:files])
+        result[:hooks].merge!(plugin_result[:hooks])
       end
 
       # Remove the marketplace itself
       remove_marketplace(marketplace_name)
 
-      files_to_remove.uniq
+      result[:files] = result[:files].uniq
+      result
     end
 
     def list_marketplaces
@@ -175,11 +182,6 @@ module Caruso
       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