aircana 0.1.0 → 1.1.0.rc1

data/lib/aircana/cli/app.rb

@@ -13,32 +13,19 @@ require_relative "commands/plan"
 require_relative "commands/work"
 
 require_relative "subcommand"
+require_relative "help_formatter"
 require_relative "commands/agents"
+require_relative "commands/hooks"
+require_relative "commands/project"
+require_relative "commands/files"
 
 module Aircana
   module CLI
     # Thor application for the primary cli
     class App < Thor
-      package_name "Aircana"
-
-      # TODO: Decide how to represent and store file groups
-      desc "add-files",
-           "interactively add files or file groups to the current context. Use tab to mark multiple files."
-      def add_files
-        AddFiles.run
-      end
+      include HelpFormatter
 
-      desc "add-dir [DIRECTORY_PATH]",
-           "add all files from the specified directory recursively to the current context"
-      def add_dir(directory_path)
-        AddDirectory.run(directory_path)
-      end
-
-      desc "clear-files",
-           "Removes all files from the current set of 'relevant files'"
-      def clear_files
-        ClearFiles.run
-      end
+      package_name "Aircana"
 
       desc "doctor", "Check system health and validate all dependencies"
       option :verbose, type: :boolean, default: false, desc: "Show detailed information about optional dependencies"
@@ -64,14 +51,26 @@ module Aircana
         Install.run
       end
 
-      desc "plan", "Launch Claude Code with planner agent for Jira ticket planning"
-      def plan
-        Plan.run
-      end
+      class FilesSubcommand < Subcommand
+        desc "add", "Interactively add files to current context"
+        def add
+          Files.add
+        end
+
+        desc "add-dir [DIRECTORY_PATH]", "Add all files from directory to context"
+        def add_dir(directory_path)
+          Files.add_dir(directory_path)
+        end
 
-      desc "work", "Launch Claude Code with worker agent for Jira ticket implementation"
-      def work
-        Work.run
+        desc "clear", "Remove all files from current context"
+        def clear
+          Files.clear
+        end
+
+        desc "list", "Show current relevant files"
+        def list
+          Files.list
+        end
       end
 
       class AgentsSubcommand < Subcommand
@@ -84,10 +83,78 @@ module Aircana
         def refresh(agent)
           Agents.refresh(agent)
         end
+
+        desc "list", "List all configured agents"
+        def list
+          Agents.list
+        end
+      end
+
+      class HooksSubcommand < Subcommand
+        desc "list", "List all available and installed hooks"
+        def list
+          Hooks.list
+        end
+
+        desc "enable HOOK_NAME", "Enable a specific hook"
+        def enable(hook_name)
+          Hooks.enable(hook_name)
+        end
+
+        desc "disable HOOK_NAME", "Disable a specific hook"
+        def disable(hook_name)
+          Hooks.disable(hook_name)
+        end
+
+        desc "create", "Create a new custom hook"
+        def create
+          Hooks.create
+        end
+
+        desc "status", "Show current hook configuration status"
+        def status
+          Hooks.status
+        end
       end
 
+      class ProjectSubcommand < Subcommand
+        desc "init", "Initialize project.json for multi-root support"
+        def init
+          Project.init
+        end
+
+        desc "add FOLDER_PATH", "Add a folder to multi-root configuration"
+        def add(folder_path)
+          Project.add(folder_path)
+        end
+
+        desc "remove FOLDER_PATH", "Remove a folder from multi-root configuration"
+        def remove(folder_path)
+          Project.remove(folder_path)
+        end
+
+        desc "list", "List all configured folders and their agents"
+        def list
+          Project.list
+        end
+
+        desc "sync", "Manually sync symlinks for multi-root agents"
+        def sync
+          Project.sync
+        end
+      end
+
+      desc "files", "Manage relevant files for context"
+      subcommand "files", FilesSubcommand
+
       desc "agents", "Create and manage agents and their knowledgebases"
       subcommand "agents", AgentsSubcommand
+
+      desc "hooks", "Manage Claude Code hooks"
+      subcommand "hooks", HooksSubcommand
+
+      desc "project", "Manage multi-root project configuration"
+      subcommand "project", ProjectSubcommand
     end
   end
 end

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "json"
 require "tty-prompt"
 require_relative "../../generators/agents_generator"
+require_relative "../../contexts/manifest"
 
 module Aircana
   module CLI
@@ -12,7 +14,7 @@ module Aircana
       class << self # rubocop:disable Metrics/ClassLength
         def refresh(agent)
           normalized_agent = normalize_string(agent)
-          perform_refresh(normalized_agent)
+          perform_manifest_aware_refresh(normalized_agent)
         rescue Aircana::Error => e
           handle_refresh_error(normalized_agent, e)
         end
@@ -47,13 +49,24 @@ module Aircana
           Aircana.human_logger.success "Agent '#{agent_name}' setup complete!"
         end
 
+        def list
+          agent_dir = Aircana.configuration.agent_knowledge_dir
+          return print_no_agents_message unless Dir.exist?(agent_dir)
+
+          agent_folders = find_agent_folders(agent_dir)
+          return print_no_agents_message if agent_folders.empty?
+
+          print_agents_list(agent_folders)
+        end
+
         private
 
         def perform_refresh(normalized_agent)
           confluence = Aircana::Contexts::Confluence.new
-          pages_count = confluence.fetch_pages_for(agent: normalized_agent)
+          result = confluence.fetch_pages_for(agent: normalized_agent)
 
-          log_refresh_result(normalized_agent, pages_count)
+          log_refresh_result(normalized_agent, result[:pages_count])
+          result
         end
 
         def log_refresh_result(normalized_agent, pages_count)
@@ -64,6 +77,31 @@ module Aircana
           end
         end
 
+        def perform_manifest_aware_refresh(normalized_agent)
+          confluence = Aircana::Contexts::Confluence.new
+
+          # Try manifest-based refresh first
+          if Aircana::Contexts::Manifest.manifest_exists?(normalized_agent)
+            Aircana.human_logger.info "Refreshing from knowledge manifest..."
+            result = confluence.refresh_from_manifest(agent: normalized_agent)
+          else
+            Aircana.human_logger.info "No manifest found, falling back to label-based search..."
+            result = confluence.fetch_pages_for(agent: normalized_agent)
+          end
+
+          log_refresh_result(normalized_agent, result[:pages_count])
+          result
+        end
+
+        def show_gitignore_recommendation
+          Aircana.human_logger.info ""
+          Aircana.human_logger.info "💡 Recommendation: Add knowledge directories to .gitignore:"
+          Aircana.human_logger.info "   echo \".aircana/agents/*/knowledge/\" >> .gitignore"
+          Aircana.human_logger.info ""
+          Aircana.human_logger.info "   This keeps knowledge sources in version control while excluding"
+          Aircana.human_logger.info "   the actual knowledge content from your repository."
+        end
+
         def log_no_pages_found(normalized_agent)
           Aircana.human_logger.info "No pages found for agent '#{normalized_agent}'. " \
                                     "Make sure pages are labeled with '#{normalized_agent}' in Confluence."
@@ -103,7 +141,8 @@ module Aircana
 
           if prompt.yes?("Would you like to fetch knowledge for this agent from Confluence now?")
             Aircana.human_logger.info "Fetching knowledge from Confluence..."
-            perform_refresh(normalized_agent_name)
+            result = perform_refresh(normalized_agent_name)
+            show_gitignore_recommendation if result[:pages_count]&.positive?
           else
             Aircana.human_logger.info(
               "Skipping knowledge fetch. You can run 'aircana agents refresh #{normalized_agent_name}' later."
@@ -143,6 +182,38 @@ module Aircana
           end
         end
 
+        def print_no_agents_message
+          Aircana.human_logger.info("No agents configured yet.")
+        end
+
+        def find_agent_folders(agent_dir)
+          Dir.entries(agent_dir).select do |entry|
+            path = File.join(agent_dir, entry)
+            File.directory?(path) && !entry.start_with?(".")
+          end
+        end
+
+        def print_agents_list(agent_folders)
+          Aircana.human_logger.info("Configured agents:")
+          agent_folders.each_with_index do |agent_name, index|
+            description = get_agent_description(agent_name)
+            Aircana.human_logger.info("  #{index + 1}. #{agent_name} - #{description}")
+          end
+          Aircana.human_logger.info("\nTotal: #{agent_folders.length} agents")
+        end
+
+        def get_agent_description(agent_name)
+          agent_config_path = File.join(
+            Aircana.configuration.agent_knowledge_dir,
+            agent_name,
+            "agent.json"
+          )
+          return "Configuration incomplete" unless File.exist?(agent_config_path)
+
+          config = JSON.parse(File.read(agent_config_path))
+          config["description"] || "No description available"
+        end
+
         def find_available_editor
           %w[code subl atom nano vim vi].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
         end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "add_files"
+require_relative "add_directory"
+require_relative "clear_files"
+require_relative "../../contexts/relevant_files"
+
+module Aircana
+  module CLI
+    module Files
+      class << self
+        def add
+          AddFiles.run
+        end
+
+        def add_dir(directory_path)
+          AddDirectory.run(directory_path)
+        end
+
+        def clear
+          ClearFiles.run
+        end
+
+        def list
+          relevant_files_dir = Aircana.configuration.relevant_project_files_dir
+          return print_no_directory_message unless Dir.exist?(relevant_files_dir)
+
+          files = get_tracked_files(relevant_files_dir)
+          return print_no_files_message if files.empty?
+
+          print_files_list(files)
+        end
+
+        private
+
+        def print_no_directory_message
+          Aircana.human_logger.info(
+            "No relevant files directory found. Use 'aircana files add' to start tracking files."
+          )
+        end
+
+        def print_no_files_message
+          Aircana.human_logger.info("No relevant files currently tracked.")
+        end
+
+        def get_tracked_files(relevant_files_dir)
+          Dir.glob("#{relevant_files_dir}/*").map do |link|
+            File.readlink(link)
+          rescue StandardError
+            link
+          end
+        end
+
+        def print_files_list(files)
+          Aircana.human_logger.info("Current relevant files:")
+          files.each_with_index do |file, index|
+            relative_path = file.start_with?(Dir.pwd) ? file.gsub("#{Dir.pwd}/", "") : file
+            Aircana.human_logger.info("  #{index + 1}. #{relative_path}")
+          end
+          Aircana.human_logger.info("\nTotal: #{files.length} files")
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../../generators/relevant_files_command_generator"
 require_relative "../../generators/relevant_files_verbose_results_generator"
 require_relative "../../generators/agents_generator"
+require_relative "../../generators/hooks_generator"
+require_relative "../../generators/project_config_generator"
 
 module Aircana
   module CLI
@@ -18,6 +20,8 @@ module Aircana
         def run
           generators.each(&:generate)
           generate_default_agents
+          generate_default_hooks
+          generate_project_config
           Aircana.human_logger.success("Re-generated #{Aircana.configuration.output_dir} files.")
         end
 
@@ -28,6 +32,21 @@ module Aircana
             Aircana::Generators::AgentsGenerator.create_default_agent(agent_name)
           end
         end
+
+        def generate_default_hooks
+          Aircana::Generators::HooksGenerator.available_default_hooks.each do |hook_name|
+            Aircana::Generators::HooksGenerator.create_default_hook(hook_name)
+          end
+        end
+
+        def generate_project_config
+          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
+
+          # Only generate if it doesn't already exist
+          return if File.exist?(project_json_path)
+
+          Aircana::Generators::ProjectConfigGenerator.new.generate
+        end
       end
     end
   end

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

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "json"
+require "tty-prompt"
+require_relative "../../generators/hooks_generator"
+require_relative "install"
+
+module Aircana
+  module CLI
+    module Hooks
+      class << self
+        def list
+          available_hooks = Aircana::Generators::HooksGenerator.all_available_hooks
+          installed_hooks_list = installed_hooks
+
+          if available_hooks.empty?
+            Aircana.human_logger.info "No hooks available."
+            return
+          end
+
+          Aircana.human_logger.info "Available Hooks:"
+          available_hooks.each do |hook_name|
+            status = installed_hooks_list.include?(hook_name) ? "[INSTALLED]" : "[AVAILABLE]"
+            description = hook_description(hook_name)
+            is_default = Aircana::Generators::HooksGenerator.available_default_hooks.include?(hook_name)
+            default_marker = is_default ? " (default)" : ""
+            Aircana.human_logger.info "  #{status} #{hook_name} - #{description}#{default_marker}"
+          end
+        end
+
+        def enable(hook_name)
+          unless Aircana::Generators::HooksGenerator.all_available_hooks.include?(hook_name)
+            Aircana.human_logger.error "Hook '#{hook_name}' is not available."
+            available_hooks_list = Aircana::Generators::HooksGenerator.all_available_hooks.join(", ")
+            Aircana.human_logger.info "Available hooks: #{available_hooks_list}"
+            return
+          end
+
+          # Generate the hook if it doesn't exist
+          Aircana::Generators::HooksGenerator.create_default_hook(hook_name)
+
+          # Install hooks to Claude settings
+          Install.run
+
+          Aircana.human_logger.success "Hook '#{hook_name}' has been enabled."
+        end
+
+        def disable(hook_name)
+          hook_file = File.join(Aircana.configuration.hooks_dir, "#{hook_name}.sh")
+
+          unless File.exist?(hook_file)
+            Aircana.human_logger.warn "Hook '#{hook_name}' is not currently enabled."
+            return
+          end
+
+          File.delete(hook_file)
+
+          # Reinstall remaining hooks to update Claude settings
+          Install.run
+
+          Aircana.human_logger.success "Hook '#{hook_name}' has been disabled."
+        end
+
+        def create
+          prompt = TTY::Prompt.new
+
+          hook_name = prompt.ask("Hook name (lowercase, no spaces):")
+          hook_name = hook_name.strip.downcase.gsub(" ", "_")
+
+          hook_event = prompt.select("Select hook event:", %w[
+                                       pre_tool_use
+                                       post_tool_use
+                                       user_prompt_submit
+                                       session_start
+                                     ])
+
+          description = prompt.ask("Brief description of what this hook does:")
+
+          # Ensure custom hook names include the event type for proper mapping
+          # unless the name already contains it
+          hook_name = "#{hook_name}_#{hook_event}" unless hook_name.include?(hook_event.gsub("_", ""))
+
+          create_custom_hook(hook_name, hook_event, description)
+        end
+
+        def status
+          settings_file = File.join(Aircana.configuration.claude_code_project_config_path, "settings.local.json")
+
+          unless File.exist?(settings_file)
+            Aircana.human_logger.info "No Claude settings file found at #{settings_file}"
+            return
+          end
+
+          begin
+            settings = JSON.parse(File.read(settings_file))
+            hooks_config = settings["hooks"]
+
+            if hooks_config.nil? || hooks_config.empty?
+              Aircana.human_logger.info "No hooks configured in Claude settings."
+            else
+              Aircana.human_logger.info "Configured hooks in Claude settings:"
+              hooks_config.each do |event, configs|
+                configs = [configs] unless configs.is_a?(Array)
+                configs.each do |config|
+                  next unless config["hooks"] && config["hooks"][0] && config["hooks"][0]["command"]
+
+                  command_path = config["hooks"][0]["command"]
+                  script_name = File.basename(command_path, ".sh")
+                  matcher_info = config["matcher"] ? " (matcher: #{config["matcher"]})" : ""
+                  Aircana.human_logger.info "  #{event}: #{script_name}#{matcher_info}"
+                end
+              end
+            end
+          rescue JSON::ParserError => e
+            Aircana.human_logger.error "Invalid JSON in settings file: #{e.message}"
+          end
+        end
+
+        private
+
+        def installed_hooks
+          return [] unless Dir.exist?(Aircana.configuration.hooks_dir)
+
+          Dir.glob("#{Aircana.configuration.hooks_dir}/*.sh").map do |file|
+            File.basename(file, ".sh")
+          end
+        end
+
+        def hook_description(hook_name)
+          descriptions = {
+            "pre_tool_use" => "General pre-tool validation hook",
+            "post_tool_use" => "General post-tool processing hook",
+            "user_prompt_submit" => "Add context to user prompts",
+            "session_start" => "Initialize session with project context",
+            "rubocop_pre_commit" => "Run RuboCop before git commits",
+            "rspec_test" => "Run RSpec tests when Ruby files are modified",
+            "bundle_install" => "Run bundle install when Gemfile changes"
+          }
+          descriptions[hook_name] || "Custom hook"
+        end
+
+        def create_custom_hook(hook_name, hook_event, description)
+          template_content = generate_custom_hook_template(hook_event, description)
+
+          hook_file = File.join(Aircana.configuration.hooks_dir, "#{hook_name}.sh")
+          Aircana.create_dir_if_needed(File.dirname(hook_file))
+
+          File.write(hook_file, template_content)
+          File.chmod(0o755, hook_file)
+
+          Aircana.human_logger.success "Custom hook created at #{hook_file}"
+          Aircana.human_logger.info "You may need to customize the hook script for your specific needs."
+
+          # Install hooks to Claude settings
+          Install.run
+          Aircana.human_logger.success "Hook installed to Claude settings"
+
+          # Optionally offer to open in editor
+          prompt = TTY::Prompt.new
+          return unless prompt.yes?("Would you like to edit the hook file now?")
+
+          open_file_in_editor(hook_file)
+        end
+
+        def generate_custom_hook_template(hook_event, description)
+          case hook_event
+          when "pre_tool_use"
+            generate_pre_tool_use_template(description)
+          when "post_tool_use"
+            generate_post_tool_use_template(description)
+          when "user_prompt_submit"
+            generate_user_prompt_submit_template(description)
+          when "session_start"
+            generate_session_start_template(description)
+          else
+            generate_basic_template(hook_event, description)
+          end
+        end
+
+        def generate_pre_tool_use_template(description)
+          <<~SCRIPT
+            #!/bin/bash
+            # Custom pre-tool-use hook: #{description}
+
+            TOOL_NAME="$1"
+            TOOL_PARAMS="$2"
+
+            # Add your custom validation logic here
+            # Return exit code 0 to allow, exit code 1 to deny
+
+            echo "Pre-tool validation: $TOOL_NAME"
+
+            # Allow by default
+            exit 0
+          SCRIPT
+        end
+
+        def generate_post_tool_use_template(description)
+          <<~SCRIPT
+            #!/bin/bash
+            # Custom post-tool-use hook: #{description}
+
+            TOOL_NAME="$1"
+            TOOL_PARAMS="$2"
+            TOOL_RESULT="$3"
+            EXIT_CODE="$4"
+
+            # Add your custom post-processing logic here
+
+            echo "Post-tool processing: $TOOL_NAME (exit code: $EXIT_CODE)"
+
+            # Always allow result to proceed
+            exit 0
+          SCRIPT
+        end
+
+        def generate_user_prompt_submit_template(description)
+          <<~SCRIPT
+            #!/bin/bash
+            # Custom user prompt submit hook: #{description}
+
+            USER_PROMPT="$1"
+
+            # Add custom context or modify the prompt here
+            # Output JSON for advanced control or simple exit code
+
+            echo "Processing user prompt"
+
+            # Simple allow - no modifications
+            exit 0
+          SCRIPT
+        end
+
+        def generate_session_start_template(description)
+          <<~SCRIPT
+            #!/bin/bash
+            # Custom session start hook: #{description}
+
+            # Add session initialization logic here
+
+            echo "Session started in $(pwd)"
+
+            # Simple allow
+            exit 0
+          SCRIPT
+        end
+
+        def generate_basic_template(hook_event, description)
+          <<~SCRIPT
+            #!/bin/bash
+            # Custom #{hook_event} hook: #{description}
+
+            # Add your custom hook logic here
+
+            exit 0
+          SCRIPT
+        end
+
+        def open_file_in_editor(file_path)
+          editor = ENV["EDITOR"] || find_available_editor
+
+          if editor
+            Aircana.human_logger.info "Opening #{file_path} in #{editor}..."
+            system("#{editor} '#{file_path}'")
+          else
+            Aircana.human_logger.warn "No editor found. Please edit #{file_path} manually."
+          end
+        end
+
+        def find_available_editor
+          %w[code subl atom nano vim vi].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
+        end
+      end
+    end
+  end
+end