aircana 3.0.0.rc1 → 3.0.0.rc2

data/lib/aircana/cli/commands/init.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "json"
+require "tty-prompt"
+require_relative "generate"
+require_relative "../../plugin_manifest"
+require_relative "../../hooks_manifest"
+
+module Aircana
+  module CLI
+    module Init # rubocop:disable Metrics/ModuleLength
+      class << self # rubocop:disable Metrics/ClassLength
+        def run(directory: nil, plugin_name: nil)
+          target_dir = resolve_target_directory(directory)
+
+          with_directory_config(target_dir) do
+            # Collect plugin metadata
+            metadata = collect_plugin_metadata(target_dir, plugin_name)
+
+            # Create plugin structure
+            create_plugin_structure(target_dir)
+
+            # Create plugin manifest
+            create_plugin_manifest(target_dir, metadata)
+
+            # Generate and install commands
+            generate_files
+            install_commands
+
+            # Install hooks
+            install_hooks
+
+            # Success message
+            display_success_message(metadata)
+          end
+        end
+
+        private
+
+        def resolve_target_directory(directory)
+          return Dir.pwd if directory.nil? || directory.empty?
+
+          dir = File.expand_path(directory)
+          FileUtils.mkdir_p(dir)
+
+          dir
+        end
+
+        def with_directory_config(target_dir)
+          original_project_dir = Aircana.configuration.project_dir
+          original_plugin_root = Aircana.configuration.plugin_root
+
+          begin
+            # Temporarily override configuration to use target directory
+            Aircana.configuration.project_dir = target_dir
+            Aircana.configuration.plugin_root = target_dir
+            Aircana.configuration.instance_variable_set(:@plugin_manifest_dir,
+                                                        File.join(target_dir, ".claude-plugin"))
+            Aircana.configuration.instance_variable_set(:@commands_dir, File.join(target_dir, "commands"))
+            Aircana.configuration.instance_variable_set(:@agents_dir, File.join(target_dir, "agents"))
+            Aircana.configuration.instance_variable_set(:@hooks_dir, File.join(target_dir, "hooks"))
+            Aircana.configuration.instance_variable_set(:@agent_knowledge_dir, File.join(target_dir, "agents"))
+
+            yield
+          ensure
+            # Restore original configuration
+            Aircana.configuration.project_dir = original_project_dir
+            Aircana.configuration.plugin_root = original_plugin_root
+            Aircana.configuration.instance_variable_set(:@plugin_manifest_dir,
+                                                        File.join(original_plugin_root, ".claude-plugin"))
+            Aircana.configuration.instance_variable_set(:@commands_dir,
+                                                        File.join(original_plugin_root, "commands"))
+            Aircana.configuration.instance_variable_set(:@agents_dir, File.join(original_plugin_root, "agents"))
+            Aircana.configuration.instance_variable_set(:@hooks_dir, File.join(original_plugin_root, "hooks"))
+            Aircana.configuration.instance_variable_set(:@agent_knowledge_dir,
+                                                        File.join(original_plugin_root, "agents"))
+          end
+        end
+
+        def collect_plugin_metadata(target_dir, plugin_name)
+          prompt = TTY::Prompt.new
+
+          default_name = plugin_name || PluginManifest.default_plugin_name(target_dir)
+
+          {
+            name: prompt.ask("Plugin name:", default: default_name),
+            version: prompt.ask("Initial version:", default: "0.1.0"),
+            description: prompt.ask("Plugin description:", default: "A Claude Code plugin created with Aircana"),
+            author: prompt.ask("Author name:"),
+            license: prompt.ask("License:", default: "MIT")
+          }
+        end
+
+        def create_plugin_structure(target_dir)
+          # Create plugin directories
+          [".claude-plugin", "commands", "agents", "hooks"].each do |dir|
+            dir_path = File.join(target_dir, dir)
+            Aircana.create_dir_if_needed(dir_path)
+            Aircana.human_logger.info("Created directory: #{dir}/")
+          end
+        end
+
+        def create_plugin_manifest(target_dir, metadata)
+          manifest = PluginManifest.new(target_dir)
+          manifest.create(metadata)
+          Aircana.human_logger.success("Created plugin manifest at .claude-plugin/plugin.json")
+        end
+
+        def generate_files
+          Aircana.human_logger.info("Generating files...")
+          Generate.run
+        end
+
+        def install_commands
+          commands_dir = Aircana.configuration.commands_dir
+          Aircana.create_dir_if_needed(commands_dir)
+
+          copy_command_files(commands_dir)
+          install_default_agents
+        end
+
+        def copy_command_files(destination_dir)
+          Dir.glob("#{Aircana.configuration.output_dir}/commands/*").each do |file|
+            Aircana.human_logger.success("Installing command: #{File.basename(file)}")
+            FileUtils.cp(file, destination_dir)
+          end
+        end
+
+        def install_default_agents
+          agents_dir = Aircana.configuration.agents_dir
+          Aircana.create_dir_if_needed(agents_dir)
+
+          copy_agent_files(agents_dir)
+        end
+
+        def copy_agent_files(destination_dir)
+          agent_files_pattern = File.join(Aircana.configuration.output_dir, "agents", "*.md")
+          Dir.glob(agent_files_pattern).each do |file|
+            agent_name = File.basename(file, ".md")
+            next unless default_agent?(agent_name)
+
+            destination_file = File.join(destination_dir, File.basename(file))
+            # Skip copying if source and destination are the same
+            next if File.expand_path(file) == File.expand_path(destination_file)
+
+            Aircana.human_logger.success("Installing default agent: #{agent_name}")
+            FileUtils.cp(file, destination_dir)
+          end
+        end
+
+        def default_agent?(agent_name)
+          require_relative "../../generators/agents_generator"
+          Aircana::Generators::AgentsGenerator.available_default_agents.include?(agent_name)
+        end
+
+        def install_hooks
+          hooks_dir = Aircana.configuration.hooks_dir
+          return unless Dir.exist?(Aircana.configuration.output_dir)
+
+          # Copy hook scripts
+          hook_files = Dir.glob("#{Aircana.configuration.output_dir}/hooks/*.sh")
+          return unless hook_files.any?
+
+          hook_files.each do |file|
+            Aircana.human_logger.success("Installing hook: #{File.basename(file)}")
+            FileUtils.cp(file, hooks_dir)
+          end
+
+          # Create hooks manifest
+          create_hooks_manifest
+        end
+
+        def create_hooks_manifest
+          hooks_config = build_hooks_config
+
+          return if hooks_config.empty?
+
+          manifest = HooksManifest.new(Aircana.configuration.plugin_root)
+          manifest.create(hooks_config)
+
+          Aircana.human_logger.success("Created hooks manifest at hooks/hooks.json")
+        end
+
+        def build_hooks_config
+          hooks = {}
+
+          # Map hook files to Claude Code hook events and their properties
+          hook_mappings = {
+            "pre_tool_use" => { event: "PreToolUse", matcher: nil },
+            "post_tool_use" => { event: "PostToolUse", matcher: nil },
+            "user_prompt_submit" => { event: "UserPromptSubmit", matcher: nil },
+            "session_start" => { event: "SessionStart", matcher: nil },
+            "notification_sqs" => { event: "Notification", matcher: nil },
+            "rubocop_pre_commit" => { event: "PreToolUse", matcher: "Bash" },
+            "rspec_test" => { event: "PostToolUse", matcher: "Bash" },
+            "bundle_install" => { event: "PostToolUse", matcher: "Bash" }
+          }
+
+          Dir.glob("#{Aircana.configuration.hooks_dir}/*.sh").each do |hook_file|
+            hook_name = File.basename(hook_file, ".sh")
+
+            # Determine mapping for this hook
+            mapping = if hook_mappings.key?(hook_name)
+                        hook_mappings[hook_name]
+                      else
+                        # For custom hooks, try to infer the event type from the filename
+                        infer_hook_mapping(hook_name)
+                      end
+
+            next unless mapping
+
+            event_key = mapping[:event]
+
+            # Create relative path using ${CLAUDE_PLUGIN_ROOT}
+            relative_path = "${CLAUDE_PLUGIN_ROOT}/hooks/#{hook_name}.sh"
+
+            hook_entry = {
+              "type" => "command",
+              "command" => relative_path
+            }
+
+            hook_config = {
+              "hooks" => [hook_entry]
+            }
+
+            # Add matcher if specified
+            hook_config["matcher"] = mapping[:matcher] if mapping[:matcher]
+
+            hooks[event_key] ||= []
+            hooks[event_key] << hook_config
+          end
+
+          hooks
+        end
+
+        def infer_hook_mapping(hook_name)
+          # Try to infer the event type from common patterns in the hook name
+          case hook_name
+          when /pre_tool_use|pre_tool|before_tool/i
+            { event: "PreToolUse", matcher: nil }
+          when /user_prompt|prompt_submit|before_prompt/i
+            { event: "UserPromptSubmit", matcher: nil }
+          when /session_start|session_init|startup/i
+            { event: "SessionStart", matcher: nil }
+          else
+            # Default to PostToolUse for unknown custom hooks and post_tool patterns
+            { event: "PostToolUse", matcher: nil }
+          end
+        end
+
+        def display_success_message(metadata)
+          Aircana.human_logger.success("\nPlugin '#{metadata[:name]}' initialized successfully!")
+          Aircana.human_logger.info("\nPlugin structure:")
+          Aircana.human_logger.info("  .claude-plugin/plugin.json  - Plugin metadata")
+          Aircana.human_logger.info("  commands/                   - Slash commands")
+          Aircana.human_logger.info("  agents/                     - Specialized agents")
+          Aircana.human_logger.info("  hooks/                      - Event hooks")
+          Aircana.human_logger.info("\nNext steps:")
+          Aircana.human_logger.info("  - Create agents: aircana agents create")
+          Aircana.human_logger.info("  - Install plugin in Claude Code")
+          Aircana.human_logger.info("  - Run: aircana plugin info")
+        end
+      end
+    end
+  end
+end

data/lib/aircana/cli/commands/plugin.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "json"
+require "tty-prompt"
+require_relative "../../plugin_manifest"
+
+module Aircana
+  module CLI
+    module Plugin # rubocop:disable Metrics/ModuleLength
+      class << self
+        def info # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          ensure_plugin_exists!
+
+          manifest = PluginManifest.new(Aircana.configuration.plugin_root)
+          data = manifest.read
+
+          Aircana.human_logger.info("Plugin Information:")
+          Aircana.human_logger.info("  Name: #{data["name"]}")
+          Aircana.human_logger.info("  Version: #{data["version"]}")
+          Aircana.human_logger.info("  Description: #{data["description"]}") if data["description"]
+          Aircana.human_logger.info("  Author: #{data["author"]}") if data["author"]
+          Aircana.human_logger.info("  License: #{data["license"]}") if data["license"]
+          Aircana.human_logger.info("  Homepage: #{data["homepage"]}") if data["homepage"]
+          Aircana.human_logger.info("  Repository: #{data["repository"]}") if data["repository"]
+
+          Aircana.human_logger.info("  Keywords: #{data["keywords"].join(", ")}") if data["keywords"]&.any?
+
+          Aircana.human_logger.info("\nManifest location: #{manifest.manifest_path}")
+        end
+
+        def update # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          ensure_plugin_exists!
+
+          manifest = PluginManifest.new(Aircana.configuration.plugin_root)
+          current_data = manifest.read
+
+          prompt = TTY::Prompt.new
+
+          # Build update hash with only fields that user wants to change
+          updates = {}
+
+          field_prompts = {
+            "description" => "Description",
+            "author" => "Author",
+            "homepage" => "Homepage URL",
+            "repository" => "Repository URL",
+            "license" => "License"
+          }
+
+          field_prompts.each do |field, label|
+            current = current_data[field]
+            value = prompt.ask("#{label}:", default: current)
+            updates[field] = value if value != current
+          end
+
+          # Handle keywords separately (array)
+          if prompt.yes?("Update keywords?")
+            current_keywords = (current_data["keywords"] || []).join(", ")
+            keywords_input = prompt.ask("Keywords (comma-separated):", default: current_keywords)
+            updates["keywords"] = keywords_input.split(",").map(&:strip) if keywords_input
+          end
+
+          if updates.empty?
+            Aircana.human_logger.info("No changes made.")
+            return
+          end
+
+          manifest.update(updates)
+          Aircana.human_logger.success("Plugin manifest updated successfully!")
+        end
+
+        def version(action = nil, bump_type = nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          ensure_plugin_exists!
+
+          manifest = PluginManifest.new(Aircana.configuration.plugin_root)
+
+          case action
+          when "bump"
+            type = bump_type&.to_sym || :patch
+            new_version = manifest.bump_version(type)
+            Aircana.human_logger.success("Version bumped to #{new_version}")
+          when "set"
+            prompt = TTY::Prompt.new
+            new_version = prompt.ask("New version:")
+            manifest.update("version" => new_version)
+            Aircana.human_logger.success("Version set to #{new_version}")
+          else
+            data = manifest.read
+            Aircana.human_logger.info("Current version: #{data["version"]}")
+          end
+        end
+
+        def validate # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          Aircana.human_logger.info("Validating plugin structure...")
+
+          errors = []
+
+          # Check plugin manifest
+          manifest = PluginManifest.new(Aircana.configuration.plugin_root)
+          if manifest.exists?
+            begin
+              manifest.validate!
+              Aircana.human_logger.success("✓ Plugin manifest is valid")
+            rescue Aircana::Error => e
+              errors << "Plugin manifest validation failed: #{e.message}"
+            end
+          else
+            errors << "Plugin manifest not found at #{manifest.manifest_path}"
+          end
+
+          # Check directory structure
+          %w[agents commands hooks].each do |dir|
+            dir_path = File.join(Aircana.configuration.plugin_root, dir)
+            if Dir.exist?(dir_path)
+              Aircana.human_logger.success("✓ Directory exists: #{dir}/")
+            else
+              errors << "Missing directory: #{dir}/"
+            end
+          end
+
+          # Check hooks manifest if hooks directory exists
+          if Dir.exist?(Aircana.configuration.hooks_dir)
+            hooks_manifest = HooksManifest.new(Aircana.configuration.plugin_root)
+            if hooks_manifest.exists?
+              begin
+                hooks_manifest.validate!
+                Aircana.human_logger.success("✓ Hooks manifest is valid")
+              rescue Aircana::Error => e
+                errors << "Hooks manifest validation failed: #{e.message}"
+              end
+            end
+          end
+
+          # Summary
+          if errors.empty?
+            Aircana.human_logger.success("\nPlugin validation passed! ✓")
+          else
+            Aircana.human_logger.error("\nValidation failed with #{errors.size} error(s):")
+            errors.each { |error| Aircana.human_logger.error("  - #{error}") }
+            exit 1
+          end
+        end
+
+        private
+
+        def ensure_plugin_exists!
+          manifest = PluginManifest.new(Aircana.configuration.plugin_root)
+          return if manifest.exists?
+
+          Aircana.human_logger.error("No plugin found in current directory.")
+          Aircana.human_logger.info("Run 'aircana init' to create a new plugin.")
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/aircana/cli/help_formatter.rb

@@ -26,7 +26,7 @@ module Aircana
           "File Management" => %w[files],
           "Agent Management" => %w[agents],
           "Hook Management" => %w[hooks],
-          "System" => %w[generate install doctor dump-context]
+          "System" => %w[generate init doctor dump-context]
         }
       end
 

data/lib/aircana/configuration.rb

@@ -4,27 +4,53 @@ module Aircana
   class Configuration
     attr_accessor :global_dir, :project_dir, :stream, :output_dir,
                   :claude_code_config_path, :claude_code_project_config_path, :agent_knowledge_dir,
-                  :hooks_dir, :confluence_base_url, :confluence_username, :confluence_api_token
+                  :hooks_dir, :confluence_base_url, :confluence_username, :confluence_api_token,
+                  :plugin_root, :plugin_manifest_dir, :commands_dir, :agents_dir
 
     def initialize
       setup_directory_paths
+      setup_plugin_paths
       setup_claude_code_paths
       setup_stream
       setup_confluence_config
     end
 
+    # Returns true if the current directory is a plugin (has .claude-plugin/plugin.json)
+    def plugin_mode?
+      File.exist?(File.join(@plugin_root, ".claude-plugin", "plugin.json"))
+    end
+
+    # Returns the path to the plugin manifest file
+    def plugin_manifest_path
+      File.join(@plugin_manifest_dir, "plugin.json")
+    end
+
+    # Returns the path to the hooks manifest file
+    def hooks_manifest_path
+      File.join(@hooks_dir, "hooks.json")
+    end
+
     private
 
     def setup_directory_paths
       @global_dir = File.join(Dir.home, ".aircana")
       @project_dir = Dir.pwd
       @output_dir = File.join(@global_dir, "aircana.out")
-      @agent_knowledge_dir = File.join(@project_dir, ".claude", "agents")
-      @hooks_dir = File.join(@project_dir, ".aircana", "hooks")
+    end
+
+    def setup_plugin_paths
+      # Plugin root is the project directory by default
+      @plugin_root = @project_dir
+      @plugin_manifest_dir = File.join(@plugin_root, ".claude-plugin")
+      @commands_dir = File.join(@plugin_root, "commands")
+      @agents_dir = File.join(@plugin_root, "agents")
+      @hooks_dir = File.join(@plugin_root, "hooks")
+      @agent_knowledge_dir = File.join(@plugin_root, "agents")
     end
 
     def setup_claude_code_paths
       @claude_code_config_path = File.join(Dir.home, ".claude")
+      # For backward compatibility, keep this but plugin mode uses plugin_root
       @claude_code_project_config_path = File.join(Dir.pwd, ".claude")
     end
 

data/lib/aircana/generators/agents_generator.rb

@@ -60,11 +60,12 @@ module Aircana
       end
 
       def default_output_path
-        File.join(Aircana.configuration.claude_code_project_config_path, "agents", "#{agent_name}.md")
+        File.join(Aircana.configuration.agents_dir, "#{agent_name}.md")
       end
 
       def knowledge_path
-        ".claude/agents/#{agent_name}/knowledge/"
+        # Use plugin-relative path for knowledge base
+        "agents/#{agent_name}/knowledge/"
       end
     end
   end

data/lib/aircana/hooks_manifest.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aircana
+  # Manages Claude Code plugin hooks manifest (hooks/hooks.json) files
+  class HooksManifest
+    VALID_EVENTS = %w[PreToolUse PostToolUse UserPromptSubmit SessionStart Notification].freeze
+    VALID_HOOK_TYPES = %w[command validation notification].freeze
+
+    attr_reader :plugin_root
+
+    def initialize(plugin_root)
+      @plugin_root = plugin_root
+    end
+
+    # Creates a new hooks manifest with the given hooks configuration
+    def create(hooks_config = {})
+      validate_hooks_config!(hooks_config)
+      write_manifest(hooks_config)
+
+      manifest_path
+    end
+
+    # Reads the existing hooks manifest
+    def read
+      return nil unless exists?
+
+      JSON.parse(File.read(manifest_path))
+    rescue JSON::ParserError => e
+      raise Aircana::Error, "Invalid JSON in hooks manifest: #{e.message}"
+    end
+
+    # Updates the hooks manifest with new values
+    def update(hooks_config = {})
+      current_data = read || {}
+      updated_data = deep_merge(current_data, hooks_config)
+
+      validate_hooks_config!(updated_data)
+      write_manifest(updated_data)
+
+      manifest_path
+    end
+
+    # Adds a hook to the manifest
+    def add_hook(event:, hook_entry:, matcher: nil)
+      validate_event!(event)
+      validate_hook_entry!(hook_entry)
+
+      current_data = read || {}
+      current_data[event] ||= []
+
+      hook_config = build_hook_config(hook_entry, matcher)
+      current_data[event] << hook_config
+
+      write_manifest(current_data)
+      manifest_path
+    end
+
+    # Removes a hook from the manifest
+    def remove_hook(event:, command:)
+      current_data = read
+      return manifest_path unless current_data && current_data[event]
+
+      current_data[event].reject! do |hook_group|
+        hook_group["hooks"]&.any? { |h| h["command"] == command }
+      end
+
+      current_data.delete(event) if current_data[event].empty?
+
+      write_manifest(current_data)
+      manifest_path
+    end
+
+    # Checks if the hooks manifest exists
+    def exists?
+      File.exist?(manifest_path)
+    end
+
+    # Returns the path to the hooks manifest
+    def manifest_path
+      File.join(plugin_root, "hooks", "hooks.json")
+    end
+
+    # Returns the hooks directory
+    def hooks_dir
+      File.join(plugin_root, "hooks")
+    end
+
+    # Validates the current manifest structure
+    def validate!
+      data = read
+      return true unless data # Empty manifest is valid
+
+      validate_hooks_config!(data)
+      true
+    end
+
+    # Converts old settings.local.json hook format to hooks.json format
+    def self.from_settings_format(settings_hooks)
+      hooks_config = {}
+
+      settings_hooks.each do |event, hook_groups|
+        hooks_config[event] = hook_groups.map do |group|
+          {
+            "hooks" => group["hooks"],
+            "matcher" => group["matcher"]
+          }.compact
+        end
+      end
+
+      hooks_config
+    end
+
+    private
+
+    def build_hook_config(hook_entry, matcher)
+      config = {
+        "hooks" => [hook_entry]
+      }
+      config["matcher"] = matcher if matcher
+      config
+    end
+
+    def write_manifest(data)
+      FileUtils.mkdir_p(hooks_dir)
+      File.write(manifest_path, JSON.pretty_generate(data))
+    end
+
+    def validate_hooks_config!(config)
+      return if config.nil? || config.empty?
+
+      config.each do |event, hook_groups|
+        validate_event!(event)
+
+        raise Aircana::Error, "Hook configuration for #{event} must be an array" unless hook_groups.is_a?(Array)
+
+        hook_groups.each do |group|
+          validate_hook_group!(group)
+        end
+      end
+    end
+
+    def validate_event!(event)
+      return if VALID_EVENTS.include?(event)
+
+      raise Aircana::Error, "Invalid hook event: #{event}. Must be one of: #{VALID_EVENTS.join(", ")}"
+    end
+
+    def validate_hook_group!(group)
+      raise Aircana::Error, "Hook group must be a hash with 'hooks' array" unless group.is_a?(Hash) && group["hooks"]
+
+      raise Aircana::Error, "Hook group 'hooks' must be an array" unless group["hooks"].is_a?(Array)
+
+      group["hooks"].each do |hook|
+        validate_hook_entry!(hook)
+      end
+    end
+
+    def validate_hook_entry!(hook)
+      raise Aircana::Error, "Hook entry must be a hash" unless hook.is_a?(Hash)
+
+      unless hook["type"] && VALID_HOOK_TYPES.include?(hook["type"])
+        raise Aircana::Error, "Hook must have a valid type: #{VALID_HOOK_TYPES.join(", ")}"
+      end
+
+      return if hook["command"]
+
+      raise Aircana::Error, "Hook must have a command"
+    end
+
+    def deep_merge(hash1, hash2)
+      result = hash1.dup
+
+      hash2.each do |key, value|
+        result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
+                        deep_merge(result[key], value)
+                      elsif result[key].is_a?(Array) && value.is_a?(Array)
+                        result[key] + value
+                      else
+                        value
+                      end
+      end
+
+      result
+    end
+  end
+end