aircana 0.1.0

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Aircana
+  module CLI
+    module DoctorHelpers
+      module Logging
+        def log_success(label, message)
+          Aircana.human_logger.success "  ✅ #{label.ljust(15)} #{message}"
+        end
+
+        def log_failure(label, message)
+          Aircana.human_logger.error "  ❌ #{label.ljust(15)} #{message}"
+        end
+
+        def log_warning(label, message)
+          Aircana.human_logger.warn "  ⚠️  #{label.ljust(15)} #{message}"
+        end
+
+        def log_info(label, message)
+          Aircana.human_logger.info "  ℹ️  #{label.ljust(15)} #{message}"
+        end
+
+        def log_remedy(message)
+          Aircana.human_logger.info "     → #{message}"
+        end
+      end
+
+      module SystemChecks
+        def command_available?(command)
+          system("which #{command}", out: File::NULL, err: File::NULL)
+        end
+
+        def claude_available?
+          claude_path = find_claude_path
+          !claude_path.nil? && File.executable?(claude_path)
+        end
+
+        def find_claude_path
+          possible_paths = [
+            File.expand_path("~/.claude/local/claude"),
+            `which claude 2>/dev/null`.strip,
+            "/usr/local/bin/claude"
+          ]
+
+          possible_paths.each do |path|
+            return path if !path.empty? && File.exist?(path) && File.executable?(path)
+          end
+
+          return "claude" if system("which claude > /dev/null 2>&1")
+
+          nil
+        end
+
+        def mcp_tool_installed?(result)
+          $CHILD_STATUS.success? && !result.include?("not found") && !result.include?("error")
+        end
+
+        def detect_os
+          return "macOS" if RUBY_PLATFORM.match?(/darwin/)
+          return "Ubuntu/Debian" if File.exist?("/etc/debian_version")
+
+          "Other"
+        end
+      end
+
+      module ConfigurationChecks
+        def confluence_configured?(config)
+          !config.confluence_base_url.to_s.empty? &&
+            !config.confluence_username.to_s.empty? &&
+            !config.confluence_api_token.to_s.empty?
+        end
+
+        def find_available_editors
+          %w[code subl atom nano vim vi].select { |cmd| command_available?(cmd) }
+        end
+
+        def check_directory(path, description)
+          expanded_path = File.expand_path(path)
+          if Dir.exist?(expanded_path)
+            log_success(File.basename(path), "#{description} exists")
+          else
+            log_info(File.basename(path), "#{description} not found")
+            log_remedy("Will be created on first use")
+          end
+        end
+      end
+
+      module InstallCommands
+        INSTALL_COMMANDS = {
+          "git" => {
+            "macOS" => "brew install git",
+            "Ubuntu/Debian" => "apt install git",
+            "Other" => "https://git-scm.com/downloads"
+          },
+          "fzf" => {
+            "macOS" => "brew install fzf",
+            "Ubuntu/Debian" => "apt install fzf",
+            "Other" => "https://github.com/junegunn/fzf#installation"
+          },
+          "bat" => {
+            "macOS" => "brew install bat",
+            "Ubuntu/Debian" => "apt install bat",
+            "Other" => "https://github.com/sharkdp/bat#installation"
+          },
+          "fd" => {
+            "macOS" => "brew install fd",
+            "Ubuntu/Debian" => "apt install fd-find",
+            "Other" => "https://github.com/sharkdp/fd#installation"
+          }
+        }.freeze
+
+        def install_command(tool)
+          os = detect_os
+          INSTALL_COMMANDS.dig(tool, os) || INSTALL_COMMANDS.dig(tool, "Other") || "Check package manager"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../shell_command"
+require_relative "../../contexts/relevant_files"
+
+module Aircana
+  module CLI
+    module DumpContext
+      class << self
+        def run(_agent_name:, verbose: true)
+          Aircana.logger.level = Logger::ERROR
+          Contexts::RelevantFiles.print(verbose:)
+        end
+
+        private
+
+        def print(context)
+          Aircana.configuration.stream.puts context
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../generators/relevant_files_command_generator"
+require_relative "../../generators/relevant_files_verbose_results_generator"
+require_relative "../../generators/agents_generator"
+
+module Aircana
+  module CLI
+    module Generate
+      class << self
+        def generators
+          @generators ||= [
+            Aircana::Generators::RelevantFilesVerboseResultsGenerator.new,
+            Aircana::Generators::RelevantFilesCommandGenerator.new
+          ]
+        end
+
+        def run
+          generators.each(&:generate)
+          generate_default_agents
+          Aircana.human_logger.success("Re-generated #{Aircana.configuration.output_dir} files.")
+        end
+
+        private
+
+        def generate_default_agents
+          Aircana::Generators::AgentsGenerator.available_default_agents.each do |agent_name|
+            Aircana::Generators::AgentsGenerator.create_default_agent(agent_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "generate"
+
+module Aircana
+  module CLI
+    module Install
+      class << self
+        def run
+          ensure_output_exists
+          install_commands_to_claude
+        end
+
+        private
+
+        def ensure_output_exists
+          return if Dir.exist?(Aircana.configuration.output_dir)
+
+          Aircana.human_logger.warn("No generated output files-auto generating now...")
+          Generate.run
+        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)
+
+          copy_command_files(claude_commands_dir)
+          install_agents_to_claude
+        end
+
+        def copy_command_files(destination_dir)
+          Dir.glob("#{Aircana.configuration.output_dir}/commands/*").each do |file|
+            Aircana.human_logger.success("Installing #{file} to #{destination_dir}")
+            FileUtils.cp(file, destination_dir)
+          end
+        end
+
+        def install_agents_to_claude
+          claude_agents_dir = File.join(Aircana.configuration.claude_code_project_config_path, "agents")
+          Aircana.create_dir_if_needed(claude_agents_dir)
+
+          copy_agent_files(claude_agents_dir)
+        end
+
+        def copy_agent_files(destination_dir)
+          agent_files_pattern = File.join(Aircana.configuration.claude_code_project_config_path, "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 #{file} to #{destination_dir}")
+            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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "generate"
+require_relative "install"
+require_relative "../../generators/agents_generator"
+
+module Aircana
+  module CLI
+    module Plan
+      class << self
+        def run
+          ensure_planner_agent_installed
+          launch_claude_with_planner
+        end
+
+        private
+
+        def ensure_planner_agent_installed
+          planner_agent_path = File.join(
+            Aircana.configuration.claude_code_config_path,
+            "agents",
+            "planner.md"
+          )
+
+          return if File.exist?(planner_agent_path)
+
+          Aircana.human_logger.info("Planner agent not found. Generating and installing...")
+          Generate.run
+          Install.run
+        end
+
+        def launch_claude_with_planner
+          prompt = "Start a planning session with the 'planner' sub-agent"
+
+          Aircana.human_logger.info("Launching Claude Code with planner agent...")
+
+          claude_path = find_claude_path
+          if claude_path
+            system("#{claude_path} \"#{prompt}\"")
+          else
+            handle_claude_not_found(prompt)
+          end
+        end
+
+        def handle_claude_not_found(prompt)
+          error_message = "Claude Code command not found. " \
+                          "Please make sure Claude Code is installed and in your PATH."
+          Aircana.human_logger.error(error_message)
+          Aircana.human_logger.info("You can manually start Claude Code and run: #{prompt}")
+        end
+
+        def find_claude_path
+          # Try common locations for Claude Code binary (same as ClaudeClient)
+          possible_paths = [
+            File.expand_path("~/.claude/local/claude"),
+            `/usr/bin/which claude`.strip,
+            "/usr/local/bin/claude"
+          ]
+
+          possible_paths.each do |path|
+            return path if !path.empty? && File.executable?(path)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "generate"
+require_relative "install"
+require_relative "../../generators/agents_generator"
+
+module Aircana
+  module CLI
+    module Work
+      class << self
+        def run
+          ensure_worker_agent_installed
+          launch_claude_with_worker
+        end
+
+        private
+
+        def ensure_worker_agent_installed
+          worker_agent_path = File.join(
+            Aircana.configuration.claude_code_config_path,
+            "agents",
+            "worker.md"
+          )
+
+          return if File.exist?(worker_agent_path)
+
+          Aircana.human_logger.info("Worker agent not found. Generating and installing...")
+          Generate.run
+          Install.run
+        end
+
+        def launch_claude_with_worker
+          prompt = "Start a work session with the 'worker' sub-agent"
+
+          Aircana.human_logger.info("Launching Claude Code with worker agent...")
+
+          claude_path = find_claude_path
+          if claude_path
+            system("#{claude_path} \"#{prompt}\"")
+          else
+            handle_claude_not_found(prompt)
+          end
+        end
+
+        def handle_claude_not_found(prompt)
+          error_message = "Claude Code command not found. " \
+                          "Please make sure Claude Code is installed and in your PATH."
+          Aircana.human_logger.error(error_message)
+          Aircana.human_logger.info("You can manually start Claude Code and run: #{prompt}")
+        end
+
+        def find_claude_path
+          # Try common locations for Claude Code binary (same as ClaudeClient)
+          possible_paths = [
+            File.expand_path("~/.claude/local/claude"),
+            `/usr/bin/which claude`.strip,
+            "/usr/local/bin/claude"
+          ]
+
+          possible_paths.each do |path|
+            return path if !path.empty? && File.executable?(path)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/aircana/cli/shell_command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Aircana
+  module CLI
+    class ShellCommand
+      def self.run(command_string)
+        # Command execution logged by human_logger elsewhere if needed
+
+        `#{command_string}`
+      end
+    end
+  end
+end

data/lib/aircana/cli/subcommand.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Aircana
+  module CLI
+    class Subcommand < Thor
+      def self.banner(command, _namespace = nil, _subcommand = false) # rubocop:disable Style/OptionalBooleanParameter
+        "#{basename} #{subcommand_prefix} #{command.usage}"
+      end
+
+      def self.subcommand_prefix
+        name.gsub(/.*::/, "").gsub(/^[A-Z]/) do |match|
+          match[0].downcase
+        end.gsub(/[A-Z]/) { |match| "-#{match[0].downcase}" } # rubocop:disable Style/MultilineBlockChain
+      end
+    end
+  end
+end

data/lib/aircana/cli.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "cli/app"
+
+module Aircana
+  module CLI
+  end
+end

data/lib/aircana/configuration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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
+
+    def initialize
+      setup_directory_paths
+      setup_claude_code_paths
+      setup_stream
+      setup_confluence_config
+    end
+
+    private
+
+    def setup_directory_paths
+      @global_dir = File.join(Dir.home, ".aircana")
+      @project_dir = Dir.pwd
+      @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")
+    end
+
+    def setup_claude_code_paths
+      @claude_code_config_path = File.join(Dir.home, ".claude")
+      @claude_code_project_config_path = File.join(Dir.pwd, ".claude")
+    end
+
+    def setup_stream
+      @stream = $stdout
+    end
+
+    def setup_confluence_config
+      @confluence_base_url = nil
+      @confluence_username = nil
+      @confluence_api_token = nil
+    end
+  end
+end

data/lib/aircana/contexts/confluence.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "reverse_markdown"
+require_relative "local"
+require_relative "confluence_logging"
+require_relative "confluence_http"
+require_relative "confluence_content"
+require_relative "confluence_setup"
+
+module Aircana
+  module Contexts
+    class Confluence
+      include HTTParty
+      include ConfluenceLogging
+      include ConfluenceHttp
+      include ConfluenceContent
+      include ConfluenceSetup
+
+      LABEL_PREFIX = "global"
+
+      def initialize
+        @local_storage = Local.new
+      end
+
+      def fetch_pages_for(agent:)
+        validate_configuration!
+        setup_httparty
+
+        pages = search_and_log_pages(agent)
+        return 0 if pages.empty?
+
+        process_pages(pages, agent)
+        pages.size
+      end
+
+      def search_and_log_pages(agent)
+        pages = ProgressTracker.with_spinner("Searching for pages labeled '#{agent}'") do
+          fetch_pages_by_label(agent)
+        end
+        log_pages_found(pages.size, agent)
+        pages
+      end
+
+      def process_pages(pages, agent)
+        ProgressTracker.with_batch_progress(pages, "Processing pages") do |page, _index|
+          store_page_as_markdown(page, agent)
+        end
+      end
+
+      private
+
+      def validate_configuration!
+        config = Aircana.configuration
+
+        validate_base_url(config)
+        validate_username(config)
+        validate_api_token(config)
+      end
+
+      def validate_base_url(config)
+        return unless config.confluence_base_url.nil? || config.confluence_base_url.empty?
+
+        raise Error, "Confluence base URL not configured"
+      end
+
+      def validate_username(config)
+        return unless config.confluence_username.nil? || config.confluence_username.empty?
+
+        raise Error, "Confluence username not configured"
+      end
+
+      def validate_api_token(config)
+        return unless config.confluence_api_token.nil? || config.confluence_api_token.empty?
+
+        raise Error, "Confluence API token not configured"
+      end
+
+      def fetch_pages_by_label(agent)
+        label_id = find_label_id(agent)
+        return [] if label_id.nil?
+
+        response = get_pages_for_label(label_id)
+        response["results"] || []
+      rescue HTTParty::Error, StandardError => e
+        handle_api_error("fetch pages for agent '#{agent}'", e, "Failed to fetch pages from Confluence")
+      end
+
+      def find_label_id(agent_name)
+        path = "/wiki/api/v2/labels"
+        query_params = { limit: 250, prefix: LABEL_PREFIX }
+        page_number = 1
+
+        label_id = search_labels_pagination(path, query_params, agent_name, page_number)
+        clear_pagination_line
+        label_id
+      end
+
+      def search_labels_pagination(path, query_params, agent_name, page_number)
+        loop do
+          response = fetch_labels_page(path, query_params, page_number)
+          label_id = find_matching_label_id(response, agent_name)
+          return label_id if label_id
+
+          next_cursor = extract_next_cursor(response)
+          break unless next_cursor
+
+          query_params[:cursor] = next_cursor
+          page_number += 1
+        end
+
+        nil
+      end
+
+      def fetch_labels_page(path, query_params, page_number)
+        log_request("GET", path, query_params.merge("Page" => page_number), pagination: true)
+        response = self.class.get(path, { query: query_params })
+        log_response(response, "Labels lookup (page #{page_number})", pagination: true)
+        validate_response(response)
+        response
+      end
+
+      def find_matching_label_id(response, agent_name)
+        labels = response["results"] || []
+        matching_label = labels.find { |label| label["name"] == agent_name }
+        matching_label&.[]("id")
+      end
+
+      def extract_next_cursor(response)
+        next_url = get_next_page_url(response)
+        return nil unless next_url&.include?("cursor=")
+
+        next_url.match(/cursor=([^&]+)/)[1]
+      end
+
+      def clear_pagination_line
+        print "\r\e[K"
+      end
+    end
+  end
+end

data/lib/aircana/contexts/confluence_content.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aircana
+  module Contexts
+    module ConfluenceContent
+      def fetch_page_content(page_id)
+        Aircana.human_logger.info("Looking for page with ID `#{page_id}`")
+        response = get_page_content(page_id)
+        response.dig("body", "storage", "value") || ""
+      rescue HTTParty::Error, StandardError => e
+        handle_api_error("fetch content for page #{page_id}", e, "Failed to fetch page content")
+      end
+
+      def convert_to_markdown(html_content)
+        return "" if html_content.nil? || html_content.empty?
+
+        ReverseMarkdown.convert(html_content, github_flavored: true)
+      end
+
+      def log_pages_found(count, agent)
+        Aircana.human_logger.info "Found #{count} pages for agent '#{agent}'"
+      end
+
+      def store_page_as_markdown(page, agent)
+        content = page&.dig("body", "storage", "value") || fetch_page_content(page&.[]("id"))
+        markdown_content = convert_to_markdown(content)
+
+        @local_storage.store_content(
+          title: page&.[]("title"),
+          content: markdown_content,
+          agent: agent
+        )
+      end
+    end
+  end
+end

data/lib/aircana/contexts/confluence_http.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aircana
+  module Contexts
+    module ConfluenceHttp
+      def get_pages_for_label(label_id)
+        path = "/wiki/api/v2/labels/#{label_id}/pages"
+        query_params = { "body-format" => "storage", limit: 100 }
+
+        log_request("GET", path, query_params)
+
+        response = self.class.get(path, { query: query_params })
+        log_response(response, "Pages for label")
+        validate_response(response)
+        response
+      end
+
+      def get_page_content(page_id)
+        path = "/rest/api/content/#{page_id}"
+        query_params = { expand: "body.storage" }
+
+        log_request("GET", path, query_params)
+
+        response = self.class.get(path, { query: query_params })
+        log_response(response, "Page content")
+        validate_response(response)
+        response
+      end
+
+      def validate_response(response)
+        return if response.success?
+
+        raise Error, "HTTP #{response.code}: #{response.message}"
+      end
+
+      def get_next_page_url(response)
+        response.dig("_links", "next")
+      end
+    end
+  end
+end