aircana 0.1.0 → 1.0.0

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "generate"
+require_relative "../../generators/project_config_generator"
 
 module Aircana
   module CLI
@@ -8,7 +10,9 @@ module Aircana
       class << self
         def run
           ensure_output_exists
+          ensure_project_config_exists
           install_commands_to_claude
+          install_hooks_to_claude
         end
 
         private
@@ -20,6 +24,14 @@ module Aircana
           Generate.run
         end
 
+        def ensure_project_config_exists
+          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+          return if File.exist?(project_json_path)
+
+          Aircana.human_logger.info("Creating project.json for multi-root support...")
+          Aircana::Generators::ProjectConfigGenerator.new.generate
+        end
+
         def install_commands_to_claude
           claude_commands_dir = File.join(Aircana.configuration.claude_code_project_config_path, "commands")
           Aircana.create_dir_if_needed(claude_commands_dir)
@@ -61,6 +73,107 @@ module Aircana
           require_relative "../../generators/agents_generator"
           Aircana::Generators::AgentsGenerator.available_default_agents.include?(agent_name)
         end
+
+        def install_hooks_to_claude
+          return unless Dir.exist?(Aircana.configuration.hooks_dir)
+
+          settings_file = File.join(Aircana.configuration.claude_code_project_config_path, "settings.local.json")
+          install_hooks_to_settings(settings_file)
+        end
+
+        def install_hooks_to_settings(settings_file)
+          settings = load_settings(settings_file)
+          hook_configs = build_hook_configs
+
+          return if hook_configs.empty?
+
+          settings["hooks"] = hook_configs
+          save_settings(settings_file, settings)
+
+          Aircana.human_logger.success("Installed hooks to #{settings_file}")
+        end
+
+        def load_settings(settings_file)
+          if File.exist?(settings_file)
+            JSON.parse(File.read(settings_file))
+          else
+            Aircana.create_dir_if_needed(File.dirname(settings_file))
+            {}
+          end
+        rescue JSON::ParserError
+          Aircana.human_logger.warn("Invalid JSON in #{settings_file}, creating new settings")
+          {}
+        end
+
+        def save_settings(settings_file, settings)
+          File.write(settings_file, JSON.pretty_generate(settings))
+        end
+
+        def build_hook_configs
+          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 },
+            "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 from project root
+            relative_path = File.join(".aircana", "hooks", "#{hook_name}.sh")
+
+            hook_entry = {
+              "hooks" => [
+                {
+                  "type" => "command",
+                  "command" => relative_path
+                }
+              ]
+            }
+
+            # Add matcher if specified
+            hook_entry["matcher"] = mapping[:matcher] if mapping[:matcher]
+
+            hooks[event_key] ||= []
+            hooks[event_key] << hook_entry
+          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
       end
     end
   end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "json"
+require "tty-prompt"
+require_relative "../../symlink_manager"
+require_relative "../../generators/project_config_generator"
+
+module Aircana
+  module CLI
+    module Project
+      class << self
+        def init
+          generator = Aircana::Generators::ProjectConfigGenerator.new
+          config_path = generator.generate
+
+          Aircana.human_logger.success "Initialized project.json at #{config_path}"
+          Aircana.human_logger.info "Add folders using: aircana project add <path>"
+        end
+
+        def add(folder_path)
+          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+
+          # Create project.json if it doesn't exist
+          init unless File.exist?(project_json_path)
+
+          # Validate folder exists
+          full_path = File.join(Aircana.configuration.project_dir, folder_path)
+          unless Dir.exist?(full_path)
+            Aircana.human_logger.error "Folder not found: #{folder_path}"
+            return
+          end
+
+          # Load existing config
+          config = JSON.parse(File.read(project_json_path))
+          config["folders"] ||= []
+
+          # Check if folder already exists
+          if config["folders"].any? { |f| f["path"] == folder_path }
+            Aircana.human_logger.warn "Folder already configured: #{folder_path}"
+            return
+          end
+
+          # Add the folder
+          config["folders"] << { "path" => folder_path }
+
+          # Save updated config
+          File.write(project_json_path, JSON.pretty_generate(config))
+
+          Aircana.human_logger.success "Added folder: #{folder_path}"
+
+          # Check what agents/knowledge would be available
+          check_folder_contents(folder_path)
+
+          # Offer to sync
+          prompt = TTY::Prompt.new
+          sync if prompt.yes?("Would you like to sync symlinks now?")
+        end
+
+        def remove(folder_path)
+          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+
+          unless File.exist?(project_json_path)
+            Aircana.human_logger.error "No project.json found. Run 'aircana project init' first."
+            return
+          end
+
+          # Load existing config
+          config = JSON.parse(File.read(project_json_path))
+          config["folders"] ||= []
+
+          # Remove the folder
+          original_count = config["folders"].size
+          config["folders"].reject! { |f| f["path"] == folder_path }
+
+          if config["folders"].size == original_count
+            Aircana.human_logger.warn "Folder not found in configuration: #{folder_path}"
+            return
+          end
+
+          # Save updated config
+          File.write(project_json_path, JSON.pretty_generate(config))
+
+          Aircana.human_logger.success "Removed folder: #{folder_path}"
+
+          # Clean up symlinks
+          Aircana::SymlinkManager.cleanup_broken_symlinks
+        end
+
+        def list
+          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+
+          unless File.exist?(project_json_path)
+            Aircana.human_logger.info "No project.json found. Run 'aircana project init' to create one."
+            return
+          end
+
+          config = JSON.parse(File.read(project_json_path))
+          folders = config["folders"] || []
+
+          if folders.empty?
+            Aircana.human_logger.info "No folders configured."
+            Aircana.human_logger.info "Add folders using: aircana project add <path>"
+            return
+          end
+
+          Aircana.human_logger.info "Configured folders:"
+          folders.each do |folder|
+            folder_path = folder["path"]
+            status = Dir.exist?(File.join(Aircana.configuration.project_dir, folder_path)) ? "✓" : "✗"
+            Aircana.human_logger.info "  #{status} #{folder_path}"
+
+            # Show available agents if folder exists
+            check_folder_contents(folder_path, indent: "    ") if status == "✓"
+          end
+        end
+
+        def sync
+          Aircana.human_logger.info "Syncing multi-root project symlinks..."
+
+          stats = Aircana::SymlinkManager.sync_multi_root_agents
+
+          if stats[:agents].zero? && stats[:knowledge].zero?
+            Aircana.human_logger.info "No agents or knowledge bases to link."
+          else
+            Aircana.human_logger.success "Sync complete: #{stats[:agents]} agents, #{stats[:knowledge]} knowledge bases"
+          end
+        end
+
+        private
+
+        def check_folder_contents(folder_path, indent: "  ")
+          agents_dir = File.join(folder_path, ".claude", "agents")
+          knowledge_dir = File.join(folder_path, ".aircana", "agents")
+
+          agents = []
+          knowledge = []
+
+          agents = Dir.glob("#{agents_dir}/*.md").map { |f| File.basename(f, ".md") } if Dir.exist?(agents_dir)
+
+          if Dir.exist?(knowledge_dir)
+            knowledge = Dir.glob("#{knowledge_dir}/*").select { |d| File.directory?(d) }
+                           .map { |d| File.basename(d) }
+          end
+
+          Aircana.human_logger.info "#{indent}Agents: #{agents.join(", ")}" if agents.any?
+
+          Aircana.human_logger.info "#{indent}Knowledge: #{knowledge.join(", ")}" if knowledge.any?
+
+          return unless agents.empty? && knowledge.empty?
+
+          Aircana.human_logger.info "#{indent}No agents or knowledge found"
+        end
+      end
+    end
+  end
+end

data/lib/aircana/cli/help_formatter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Aircana
+  module CLI
+    # Custom help formatter to organize commands into logical groups
+    module HelpFormatter
+      def help(command = nil, subcommand: false)
+        if command
+          super
+        else
+          print_grouped_commands
+        end
+      end
+
+      private
+
+      def print_grouped_commands
+        say "Aircana - Context Management for Claude Code", :bold
+        command_groups.each { |group_name, commands| print_command_group(group_name, commands) }
+        say
+        say "Use 'aircana help [COMMAND]' for more information on a specific command.", :green
+      end
+
+      def command_groups
+        {
+          "File Management" => %w[files],
+          "Agent Management" => %w[agents],
+          "Hook Management" => %w[hooks],
+          "Project Management" => %w[project],
+          "System" => %w[generate install doctor dump-context]
+        }
+      end
+
+      def print_command_group(group_name, group_commands)
+        print_group_header(group_name)
+        group_commands.each { |cmd_name| print_group_command(cmd_name) }
+      end
+
+      def print_group_header(group_name)
+        say
+        say "#{group_name}:", :yellow
+      end
+
+      def print_group_command(cmd_name)
+        cmd = self.class.commands[cmd_name]
+        return unless cmd
+
+        if subcommand?(cmd_name)
+          print_subcommand_group(cmd_name, cmd)
+        else
+          print_command(cmd)
+        end
+      end
+
+      def subcommand?(cmd_name)
+        %w[files agents hooks project].include?(cmd_name)
+      end
+
+      def print_subcommand_group(subcommand_name, cmd)
+        subcommand_class = get_subcommand_class(subcommand_name)
+        return print_command(cmd) unless subcommand_class
+
+        print_subcommands(subcommand_class, subcommand_name)
+      end
+
+      def get_subcommand_class(subcommand_name)
+        class_name = "#{subcommand_name.capitalize}Subcommand"
+        return self.class.const_get(class_name) if self.class.const_defined?(class_name)
+
+        nil
+      rescue NameError
+        nil
+      end
+
+      def print_subcommands(subcommand_class, subcommand_name)
+        subcommand_class.commands.each_value do |sub_cmd|
+          usage = "aircana #{subcommand_name} #{sub_cmd.usage}"
+          desc = sub_cmd.description
+          say "  #{usage.ljust(35)} # #{desc}"
+        end
+      end
+
+      def print_command(cmd)
+        usage = "aircana #{cmd.usage}"
+        desc = cmd.description
+        say "  #{usage.ljust(35)} # #{desc}"
+      end
+    end
+  end
+end

data/lib/aircana/cli/subcommand.rb

@@ -10,7 +10,8 @@ module Aircana
       end
 
       def self.subcommand_prefix
-        name.gsub(/.*::/, "").gsub(/^[A-Z]/) do |match|
+        # Extract the main command name from class name (e.g., "FilesSubcommand" -> "files")
+        name.gsub(/.*::/, "").gsub(/Subcommand$/, "").gsub(/^[A-Z]/) do |match|
           match[0].downcase
         end.gsub(/[A-Z]/) { |match| "-#{match[0].downcase}" } # rubocop:disable Style/MultilineBlockChain
       end

data/lib/aircana/configuration.rb

@@ -4,7 +4,7 @@ module Aircana
   class Configuration
     attr_accessor :global_dir, :project_dir, :relevant_project_files_dir, :stream, :output_dir,
                   :claude_code_config_path, :claude_code_project_config_path, :agent_knowledge_dir,
-                  :confluence_base_url, :confluence_username, :confluence_api_token
+                  :hooks_dir, :confluence_base_url, :confluence_username, :confluence_api_token
 
     def initialize
       setup_directory_paths
@@ -21,6 +21,7 @@ module Aircana
       @relevant_project_files_dir = File.join(@project_dir, ".aircana", "relevant_files")
       @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_claude_code_paths

data/lib/aircana/generators/agents_generator.rb

@@ -68,7 +68,7 @@ module Aircana
       end
 
       def knowledge_path
-        ".aircana/agents/#{agent_name}/knowledge"
+        ".aircana/agents/#{agent_name}/knowledge/"
       end
     end
   end

data/lib/aircana/generators/hooks_generator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "base_generator"
+
+module Aircana
+  module Generators
+    class HooksGenerator < BaseGenerator
+      # All available hook types (for manual creation)
+      ALL_HOOK_TYPES = %w[
+        pre_tool_use
+        post_tool_use
+        user_prompt_submit
+        session_start
+        rubocop_pre_commit
+        rspec_test
+        bundle_install
+      ].freeze
+
+      # Default hooks that are auto-installed
+      DEFAULT_HOOK_TYPES = %w[
+        session_start
+      ].freeze
+
+      class << self
+        def available_default_hooks
+          DEFAULT_HOOK_TYPES
+        end
+
+        def all_available_hooks
+          ALL_HOOK_TYPES
+        end
+
+        def create_default_hook(hook_name)
+          return unless all_available_hooks.include?(hook_name)
+
+          template_path = File.join(File.dirname(__FILE__), "..", "templates", "hooks", "#{hook_name}.erb")
+          output_path = File.join(Aircana.configuration.hooks_dir, "#{hook_name}.sh")
+
+          generator = new(file_in: template_path, file_out: output_path)
+          generator.generate
+        end
+
+        def create_all_default_hooks
+          available_default_hooks.each { |hook_name| create_default_hook(hook_name) }
+        end
+      end
+
+      def initialize(hook_name: nil, **)
+        @hook_name = hook_name
+
+        if hook_name
+          template_path = File.join(File.dirname(__FILE__), "..", "templates", "hooks", "#{hook_name}.erb")
+          output_path = File.join(Aircana.configuration.hooks_dir, "#{hook_name}.sh")
+          super(file_in: template_path, file_out: output_path)
+        else
+          super(**)
+        end
+      end
+
+      def generate
+        result = super
+        make_executable if File.exist?(file_out)
+        result
+      end
+
+      protected
+
+      def locals
+        super.merge(
+          hook_name: @hook_name,
+          project_root: Dir.pwd
+        )
+      end
+
+      private
+
+      def make_executable
+        File.chmod(0o755, file_out)
+      end
+    end
+  end
+end

data/lib/aircana/generators/project_config_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base_generator"
+require "json"
+
+module Aircana
+  module Generators
+    class ProjectConfigGenerator < BaseGenerator
+      def initialize(file_in: nil, file_out: nil)
+        super(
+          file_in: file_in || default_template_path,
+          file_out: file_out || default_output_path
+        )
+      end
+
+      def generate
+        # Create the project.json with default content
+        project_config = default_project_config
+
+        Aircana.create_dir_if_needed(File.dirname(file_out))
+        File.write(file_out, JSON.pretty_generate(project_config))
+
+        Aircana.human_logger.success "Generated project.json at #{file_out}"
+        file_out
+      end
+
+      private
+
+      def default_template_path
+        # We don't use a template for this, generate directly
+        nil
+      end
+
+      def default_output_path
+        File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+      end
+
+      def default_project_config
+        {
+          "folders" => [],
+          "_comment" => [
+            "Add folders to include agents from sub-projects",
+            "Example:",
+            "  'folders': [",
+            "    { 'path': 'frontend' },",
+            "    { 'path': 'backend' },",
+            "    { 'path': 'shared/utils' }",
+            "  ]"
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/aircana/symlink_manager.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aircana
+  class SymlinkManager
+    class << self
+      def sync_multi_root_agents
+        project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+
+        unless File.exist?(project_json_path)
+          Aircana.human_logger.info "No project.json found, skipping multi-root sync"
+          return { agents: 0, knowledge: 0 }
+        end
+
+        begin
+          config = JSON.parse(File.read(project_json_path))
+          folders = config["folders"] || []
+
+          if folders.empty?
+            Aircana.human_logger.info "No folders configured in project.json"
+            return { agents: 0, knowledge: 0 }
+          end
+
+          cleanup_broken_symlinks
+          create_symlinks_for_folders(folders)
+        rescue JSON::ParserError => e
+          Aircana.human_logger.error "Invalid JSON in project.json: #{e.message}"
+          { agents: 0, knowledge: 0 }
+        end
+      end
+
+      def cleanup_broken_symlinks
+        claude_agents_dir = File.join(Aircana.configuration.project_dir, ".claude", "agents")
+        aircana_agents_dir = File.join(Aircana.configuration.project_dir, ".aircana", "agents")
+
+        [claude_agents_dir, aircana_agents_dir].each do |dir|
+          next unless Dir.exist?(dir)
+
+          Dir.glob("#{dir}/*").each do |path|
+            if File.symlink?(path) && !File.exist?(path)
+              File.delete(path)
+              Aircana.human_logger.info "Removed broken symlink: #{path}"
+            end
+          end
+        end
+      end
+
+      def create_symlinks_for_folders(folders)
+        stats = { agents: 0, knowledge: 0 }
+
+        folders.each do |folder_config|
+          folder_path = folder_config["path"]
+          next unless folder_path_valid?(folder_path)
+
+          prefix = folder_path.tr("/", "_")
+
+          stats[:agents] += link_agents(folder_path, prefix)
+          stats[:knowledge] += link_knowledge(folder_path, prefix)
+        end
+
+        Aircana.human_logger.success "Linked #{stats[:agents]} agents and #{stats[:knowledge]} knowledge bases"
+        stats
+      end
+
+      def link_agents(folder_path, prefix)
+        source_dir = File.join(folder_path, ".claude", "agents")
+        target_dir = File.join(Aircana.configuration.project_dir, ".claude", "agents")
+
+        return 0 unless Dir.exist?(source_dir)
+
+        FileUtils.mkdir_p(target_dir)
+        linked = 0
+
+        Dir.glob("#{source_dir}/*.md").each do |agent_file|
+          agent_name = File.basename(agent_file, ".md")
+          link_name = "#{prefix}_#{agent_name}.md"
+          target_path = File.join(target_dir, link_name)
+
+          # Use relative paths for symlinks
+          relative_path = calculate_relative_path(target_dir, agent_file)
+
+          File.symlink(relative_path, target_path) unless File.exist?(target_path)
+          linked += 1
+          Aircana.human_logger.info "Linked agent: #{link_name}"
+        end
+
+        linked
+      end
+
+      def link_knowledge(folder_path, prefix)
+        source_dir = File.join(folder_path, ".aircana", "agents")
+        target_dir = File.join(Aircana.configuration.project_dir, ".aircana", "agents")
+
+        return 0 unless Dir.exist?(source_dir)
+
+        FileUtils.mkdir_p(target_dir)
+        linked = 0
+
+        Dir.glob("#{source_dir}/*").each do |agent_dir|
+          next unless File.directory?(agent_dir)
+
+          agent_name = File.basename(agent_dir)
+          link_name = "#{prefix}_#{agent_name}"
+          target_path = File.join(target_dir, link_name)
+
+          # Use relative paths for symlinks
+          relative_path = calculate_relative_path(target_dir, agent_dir)
+
+          File.symlink(relative_path, target_path) unless File.exist?(target_path)
+          linked += 1
+          Aircana.human_logger.info "Linked knowledge: #{link_name}"
+        end
+
+        linked
+      end
+
+      def folder_path_valid?(folder_path)
+        full_path = File.join(Aircana.configuration.project_dir, folder_path)
+
+        unless Dir.exist?(full_path)
+          Aircana.human_logger.warn "Folder not found: #{folder_path}"
+          return false
+        end
+
+        true
+      end
+
+      def calculate_relative_path(from_dir, to_path)
+        # Calculate the relative path from one directory to another
+        from = Pathname.new(File.expand_path(from_dir))
+        to = Pathname.new(File.expand_path(to_path))
+        to.relative_path_from(from).to_s
+      end
+    end
+  end
+end