aircana 2.0.0 → 3.0.0.rc2

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

@@ -3,7 +3,7 @@
 require "json"
 require "tty-prompt"
 require_relative "../../generators/hooks_generator"
-require_relative "install"
+require_relative "init"
 
 module Aircana
   module CLI
@@ -40,7 +40,7 @@ module Aircana
           Aircana::Generators::HooksGenerator.create_default_hook(hook_name)
 
           # Install hooks to Claude settings
-          Install.run
+          Init.run
 
           Aircana.human_logger.success "Hook '#{hook_name}' has been enabled."
         end
@@ -56,7 +56,7 @@ module Aircana
           File.delete(hook_file)
 
           # Reinstall remaining hooks to update Claude settings
-          Install.run
+          Init.run
 
           Aircana.human_logger.success "Hook '#{hook_name}' has been disabled."
         end
@@ -152,7 +152,7 @@ module Aircana
           Aircana.human_logger.info "You may need to customize the hook script for your specific needs."
 
           # Install hooks to Claude settings
-          Install.run
+          Init.run
           Aircana.human_logger.success "Hook installed to Claude settings"
 
           # Optionally offer to open in editor

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,8 +26,7 @@ module Aircana
           "File Management" => %w[files],
           "Agent Management" => %w[agents],
           "Hook Management" => %w[hooks],
-          "Project Management" => %w[project],
-          "System" => %w[generate install doctor dump-context]
+          "System" => %w[generate init doctor dump-context]
         }
       end
 
@@ -53,7 +52,7 @@ module Aircana
       end
 
       def subcommand?(cmd_name)
-        %w[files agents hooks project].include?(cmd_name)
+        %w[files agents hooks].include?(cmd_name)
       end
 
       def print_subcommand_group(subcommand_name, cmd)

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, ".aircana", "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/contexts/manifest.rb

@@ -73,14 +73,7 @@ module Aircana
         end
 
         def resolve_agent_path(agent)
-          base_path = File.join(Aircana.configuration.agent_knowledge_dir, agent)
-
-          # If this is a symlink (multi-root scenario), resolve to original
-          if File.symlink?(base_path)
-            File.readlink(base_path)
-          else
-            base_path
-          end
+          File.join(Aircana.configuration.agent_knowledge_dir, agent)
         end
 
         def build_manifest_data(agent, sources)

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
-        ".aircana/agents/#{agent_name}/knowledge/"
+        # Use plugin-relative path for knowledge base
+        "agents/#{agent_name}/knowledge/"
       end
     end
   end