aircana 0.1.0

data/lib/aircana/cli/app.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "commands/add_files"
+require_relative "commands/add_directory"
+require_relative "commands/clear_files"
+require_relative "commands/doctor"
+require_relative "commands/dump_context"
+require_relative "commands/generate"
+require_relative "commands/install"
+require_relative "commands/plan"
+require_relative "commands/work"
+
+require_relative "subcommand"
+require_relative "commands/agents"
+
+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
+
+      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
+
+      desc "doctor", "Check system health and validate all dependencies"
+      option :verbose, type: :boolean, default: false, desc: "Show detailed information about optional dependencies"
+      def doctor
+        exit_code = Doctor.run(verbose: options[:verbose])
+        exit(exit_code)
+      end
+
+      desc "dump-context",
+           "dumps relevant files, knowledge, memories, and decisions for the specified agent"
+      option :verbose, type: :boolean, default: true
+      def dump_context(agent_name)
+        DumpContext.run(agent_name: agent_name, verbose: options[:verbose])
+      end
+
+      desc "generate", "Generates all configured files and dumps the configured output directory"
+      def generate
+        Generate.run
+      end
+
+      desc "install", "Copies the generated files from `generate` to the proper directories in Claude Code config."
+      def install
+        Install.run
+      end
+
+      desc "plan", "Launch Claude Code with planner agent for Jira ticket planning"
+      def plan
+        Plan.run
+      end
+
+      desc "work", "Launch Claude Code with worker agent for Jira ticket implementation"
+      def work
+        Work.run
+      end
+
+      class AgentsSubcommand < Subcommand
+        desc "create", "Create a new agent"
+        def create
+          Agents.create
+        end
+
+        desc "refresh AGENT", "Refresh agent knowledge from Confluence pages with matching labels"
+        def refresh(agent)
+          Agents.refresh(agent)
+        end
+      end
+
+      desc "agents", "Create and manage agents and their knowledgebases"
+      subcommand "agents", AgentsSubcommand
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../../contexts/relevant_files"
+
+module Aircana
+  module CLI
+    module AddDirectory
+      class << self
+        def run(directory_path)
+          return unless directory_valid?(directory_path)
+
+          selected_files = collect_files_recursively(directory_path)
+          return log_no_files_found(directory_path) if selected_files.empty?
+
+          return unless confirm_large_operation?(selected_files.size, directory_path)
+
+          process_files(directory_path, selected_files)
+        end
+
+        private
+
+        def directory_valid?(directory_path)
+          unless File.directory?(directory_path)
+            Aircana.human_logger.error "Directory not found: #{directory_path}"
+            return false
+          end
+
+          unless File.readable?(directory_path)
+            Aircana.human_logger.error "Directory not readable: #{directory_path}"
+            return false
+          end
+
+          true
+        end
+
+        def log_no_files_found(directory_path)
+          Aircana.human_logger.info "No files found in directory: #{directory_path}"
+        end
+
+        def confirm_large_operation?(file_count, directory_path)
+          return true if file_count <= 50
+
+          show_large_operation_warning(file_count, directory_path)
+          TTY::Prompt.new.yes?("Continue with adding #{file_count} files?")
+        end
+
+        def show_large_operation_warning(file_count, directory_path)
+          estimated_size = estimate_total_size(directory_path, file_count)
+          Aircana.human_logger.warn "Large directory operation detected:"
+          Aircana.human_logger.info "  Directory: #{directory_path}"
+          Aircana.human_logger.info "  Files: #{file_count}"
+          Aircana.human_logger.info "  Estimated size: #{estimated_size}"
+          Aircana.human_logger.warn "  This may result in high token usage with Claude"
+        end
+
+        def estimate_total_size(directory_path, file_count)
+          sample_files = get_sample_files(directory_path, file_count)
+          return "Unknown" if sample_files.empty?
+
+          total_bytes = calculate_sample_size(sample_files)
+          estimated_total = extrapolate_total_size(total_bytes, sample_files.size, file_count)
+          format_file_size(estimated_total)
+        end
+
+        def get_sample_files(directory_path, file_count)
+          Dir.glob(File.join(directory_path, "**", "*"))
+             .reject { |f| File.directory?(f) }
+             .sample([file_count, 10].min)
+        end
+
+        def calculate_sample_size(sample_files)
+          sample_files.sum do |f|
+            File.size(f)
+          rescue StandardError
+            0
+          end
+        end
+
+        def extrapolate_total_size(total_bytes, sample_size, file_count)
+          avg_size = total_bytes / sample_size.to_f
+          (avg_size * file_count).to_i
+        end
+
+        def format_file_size(bytes)
+          units = %w[B KB MB GB]
+          size = bytes.to_f
+          unit_index = 0
+
+          while size >= 1024 && unit_index < units.length - 1
+            size /= 1024
+            unit_index += 1
+          end
+
+          "#{size.round(1)} #{units[unit_index]}"
+        end
+
+        def process_files(directory_path, selected_files)
+          file_count = selected_files.length
+          Aircana.human_logger.info "Found #{file_count} files in directory: #{directory_path}"
+
+          ProgressTracker.with_spinner("Adding #{file_count} files to context") do
+            Contexts::RelevantFiles.add(selected_files)
+          end
+
+          Aircana.human_logger.success "Successfully added #{file_count} files from directory"
+        end
+
+        def log_token_warning(file_count)
+          Aircana.human_logger.warn "Large number of files (#{file_count}) may result in high token usage"
+        end
+
+        def collect_files_recursively(directory_path)
+          Dir.glob(File.join(directory_path, "**", "*"), File::FNM_DOTMATCH)
+             .reject { |path| File.directory?(path) }
+             .reject { |path| should_ignore_file?(path) }
+        end
+
+        def should_ignore_file?(file_path)
+          ignore_patterns.any? { |pattern| file_path.match?(pattern) }
+        end
+
+        def ignore_patterns
+          directory_patterns + file_patterns
+        end
+
+        def directory_patterns
+          [
+            %r{/\.git/}, %r{/node_modules/}, %r{/\.vscode/}, %r{/\.idea/},
+            %r{/coverage/}, %r{/dist/}, %r{/build/}, %r{/tmp/}, %r{/vendor/},
+            %r{/\.bundle/}, %r{/\.rvm/}, %r{/\.rbenv/}
+          ]
+        end
+
+        def file_patterns
+          [
+            %r{/\.DS_Store$}, %r{/log/.*\.log$},
+            /\.(jpg|jpeg|png|gif|bmp|tiff|svg|ico|webp)$/i,
+            /\.(mp4|avi|mkv|mov|wmv|flv|webm)$/i,
+            /\.(mp3|wav|flac|aac|ogg)$/i,
+            /\.(zip|tar|gz|rar|7z|bz2)$/i,
+            /\.(exe|dll|so|dylib)$/i
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../shell_command"
+require_relative "../../contexts/relevant_files"
+
+module Aircana
+  module CLI
+    module AddFiles
+      class << self
+        def run
+          selected_files = FzfHelper.select_files_interactively(
+            header: "Select files for Claude context (Ctrl+A: select all, ?: toggle preview)"
+          )
+
+          if selected_files.empty?
+            Aircana.human_logger.info "No files selected. Exiting."
+            return
+          end
+
+          Aircana.human_logger.success "Selected #{selected_files.size} files for context"
+          Contexts::RelevantFiles.add(selected_files)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../../generators/agents_generator"
+
+module Aircana
+  module CLI
+    module Agents # rubocop:disable Metrics/ModuleLength
+      SUPPORTED_CLAUDE_MODELS = %w[sonnet haiku inherit].freeze
+      SUPPORTED_CLAUDE_COLORS = %w[red blue green yellow purple orange pink cyan].freeze
+
+      class << self # rubocop:disable Metrics/ClassLength
+        def refresh(agent)
+          normalized_agent = normalize_string(agent)
+          perform_refresh(normalized_agent)
+        rescue Aircana::Error => e
+          handle_refresh_error(normalized_agent, e)
+        end
+
+        def create # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          prompt = TTY::Prompt.new
+
+          agent_name = prompt.ask("Agent name:")
+          short_description = prompt.ask("Briefly describe what your agent does:")
+          model = prompt.select("Select a model for your agent:", SUPPORTED_CLAUDE_MODELS)
+          color = prompt.select("Select a color for your agent:", SUPPORTED_CLAUDE_COLORS)
+
+          description = description_from_claude(short_description)
+          normalized_agent_name = normalize_string(agent_name)
+
+          file = Generators::AgentsGenerator.new(
+            agent_name: normalized_agent_name,
+            description:,
+            short_description:,
+            model: normalize_string(model),
+            color: normalize_string(color)
+          ).generate
+
+          Aircana.human_logger.success "Agent created at #{file}"
+
+          # Prompt for knowledge fetching
+          prompt_for_knowledge_fetch(prompt, normalized_agent_name)
+
+          # Prompt for agent file review
+          prompt_for_agent_review(prompt, file)
+
+          Aircana.human_logger.success "Agent '#{agent_name}' setup complete!"
+        end
+
+        private
+
+        def perform_refresh(normalized_agent)
+          confluence = Aircana::Contexts::Confluence.new
+          pages_count = confluence.fetch_pages_for(agent: normalized_agent)
+
+          log_refresh_result(normalized_agent, pages_count)
+        end
+
+        def log_refresh_result(normalized_agent, pages_count)
+          if pages_count.positive?
+            Aircana.human_logger.success "Successfully refreshed #{pages_count} pages for agent '#{normalized_agent}'"
+          else
+            log_no_pages_found(normalized_agent)
+          end
+        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."
+        end
+
+        def handle_refresh_error(normalized_agent, error)
+          Aircana.human_logger.error "Failed to refresh agent '#{normalized_agent}': #{error.message}"
+          exit 1
+        end
+
+        def normalize_string(string)
+          string.strip.downcase.gsub(" ", "-")
+        end
+
+        def description_from_claude(description)
+          prompt = build_agent_description_prompt(description)
+          claude_client = Aircana::LLM::ClaudeClient.new
+          claude_client.prompt(prompt)
+        end
+
+        def build_agent_description_prompt(description)
+          <<~PROMPT
+            Create a concise Claude Code agent description file (without frontmatter)
+            for an agent that is described as: #{description}.
+
+            The agent should be specialized and focused on its domain knowledge.
+            Include instructions that the agent should primarily rely on information
+            from its knowledge base rather than general knowledge when answering questions
+            within its domain.
+
+            Print the output to STDOUT only, without any additional commentary.
+          PROMPT
+        end
+
+        def prompt_for_knowledge_fetch(prompt, normalized_agent_name) # rubocop:disable Metrics/MethodLength
+          return unless confluence_configured?
+
+          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)
+          else
+            Aircana.human_logger.info(
+              "Skipping knowledge fetch. You can run 'aircana agents refresh #{normalized_agent_name}' later."
+            )
+          end
+        rescue Aircana::Error => e
+          Aircana.human_logger.warn "Failed to fetch knowledge: #{e.message}"
+          Aircana.human_logger.info "You can try again later with 'aircana agents refresh #{normalized_agent_name}'"
+        end
+
+        def prompt_for_agent_review(prompt, file_path)
+          Aircana.human_logger.info "Agent file created at: #{file_path}"
+
+          return unless prompt.yes?("Would you like to review and edit the agent file?")
+
+          open_file_in_editor(file_path)
+        end
+
+        def confluence_configured? # rubocop:disable Metrics/AbcSize
+          config = Aircana.configuration
+
+          base_url_present = !config.confluence_base_url.nil? && !config.confluence_base_url.empty?
+          username_present = !config.confluence_username.nil? && !config.confluence_username.empty?
+          token_present = !config.confluence_api_token.nil? && !config.confluence_api_token.empty?
+
+          base_url_present && username_present && token_present
+        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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../shell_command"
+require_relative "../../contexts/relevant_files"
+
+module Aircana
+  module CLI
+    module ClearFiles
+      class << self
+        def run
+          Contexts::RelevantFiles.remove_all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "English"
+require_relative "doctor_helpers"
+require_relative "doctor_checks"
+
+module Aircana
+  module CLI
+    module Doctor
+      class << self
+        include DoctorHelpers::Logging
+        include DoctorHelpers::SystemChecks
+        include DoctorHelpers::ConfigurationChecks
+        include DoctorHelpers::InstallCommands
+        include DoctorChecks::ClaudeIntegration
+        include DoctorChecks::AircanaConfiguration
+        include DoctorChecks::OptionalIntegrations
+
+        def run(verbose: false)
+          @verbose = verbose
+          @issues_found = false
+
+          Aircana.human_logger.info "🔍 Checking Aircana system health...\n"
+
+          check_required_dependencies
+          check_claude_integration
+          check_optional_dependencies
+          check_aircana_configuration
+          check_optional_integrations
+
+          display_summary
+          @issues_found ? 1 : 0
+        end
+
+        private
+
+        def check_required_dependencies
+          Aircana.human_logger.info "Required Dependencies:"
+
+          check_command("git", "version control operations", required: true)
+          check_command("fzf", "interactive file selection", required: true)
+        end
+
+        def check_optional_dependencies
+          Aircana.human_logger.info "\nOptional Dependencies:"
+
+          check_optional_tool("bat", "Enhanced file previews available", "will use basic cat for previews")
+          check_optional_tool("fd", "Fast file searching available", "will use find command")
+        end
+
+        def check_optional_tool(tool, success_message, fallback_message)
+          if command_available?(tool)
+            log_success(tool, success_message)
+          else
+            log_info(tool, "Not installed (#{fallback_message})")
+            log_remedy("Install with: #{install_command(tool)}") if @verbose
+          end
+        end
+
+        def display_summary
+          Aircana.human_logger.info "\n#{"─" * 50}"
+
+          if @issues_found
+            Aircana.human_logger.error "❌ Some issues were found. Please review the remediation steps above."
+          else
+            Aircana.human_logger.success "✅ All checks passed! Aircana is ready to use."
+          end
+        end
+
+        def check_command(command, purpose, required: false)
+          if command_available?(command)
+            log_success(command, "Installed (#{purpose})")
+          elsif required
+            log_failure(command, "Not installed (required for #{purpose})")
+            log_remedy("Install with: #{install_command(command)}")
+            @issues_found = true
+          else
+            log_warning(command, "Not installed (#{purpose})")
+            log_remedy("Install with: #{install_command(command)}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Aircana
+  module CLI
+    module DoctorChecks
+      module ClaudeIntegration
+        def check_claude_integration
+          Aircana.human_logger.info "\nClaude Code Integration:"
+
+          if claude_available?
+            log_success("claude", "Claude Code installed")
+            check_mcp_tools
+          else
+            log_failure("claude", "Claude Code not installed")
+            log_remedy("Install Claude Code from: https://claude.ai/download")
+            @issues_found = true
+          end
+
+          check_claude_directories
+        end
+
+        def check_mcp_tools
+          claude_path = find_claude_path
+          return unless claude_path
+
+          check_jira_mcp_tool(claude_path)
+        rescue StandardError => e
+          log_warning("MCP Jira", "Could not check MCP tool: #{e.message}")
+        end
+
+        def check_jira_mcp_tool(claude_path)
+          result = `#{claude_path} mcp get jira 2>&1`
+          if mcp_tool_installed?(result)
+            log_success("MCP Jira", "Atlassian/Jira MCP tool installed")
+          else
+            log_failure("MCP Jira", "Atlassian/Jira MCP tool not found")
+            log_remedy("Install with: claude mcp add --transport sse atlassian https://mcp.atlassian.com/v1/sse")
+            @issues_found = true
+          end
+        end
+
+        def check_claude_directories
+          project_claude = File.join(Dir.pwd, ".claude")
+          if Dir.exist?(project_claude)
+            log_success(".claude", "Project Claude config directory exists")
+          else
+            log_warning(".claude", "Project Claude config directory not found")
+            log_remedy("Will be created when running 'aircana install'")
+          end
+        end
+      end
+
+      module AircanaConfiguration
+        def check_aircana_configuration
+          Aircana.human_logger.info "\nAircana Configuration:"
+
+          check_directory("~/.aircana", "Global Aircana directory")
+          check_directory(".aircana", "Project Aircana directory")
+          check_agents_status
+          check_relevant_files_status
+        end
+
+        def check_agents_status
+          agents_dir = File.join(Dir.pwd, ".aircana", "agents")
+          if Dir.exist?(agents_dir) && !Dir.empty?(agents_dir)
+            agent_count = Dir.glob(File.join(agents_dir, "*.md")).size
+            log_success("agents", "#{agent_count} agent(s) configured")
+          elsif Dir.exist?(agents_dir)
+            log_info("agents", "Agents directory exists but is empty")
+          else
+            log_info("agents", "No agents configured yet")
+            log_remedy("Create agents with: aircana agents create")
+          end
+        end
+
+        def check_relevant_files_status
+          relevant_files_dir = File.join(Dir.pwd, ".aircana", "relevant_files")
+          if Dir.exist?(relevant_files_dir) && !Dir.empty?(relevant_files_dir)
+            file_count = Dir.glob(File.join(relevant_files_dir, "*")).size
+            log_success("relevant_files", "#{file_count} file(s) in context")
+          else
+            log_info("relevant_files", "No relevant files added yet")
+            log_remedy("Add files with: aircana add-files")
+          end
+        end
+      end
+
+      module OptionalIntegrations
+        def check_optional_integrations
+          Aircana.human_logger.info "\nOptional Integrations:"
+
+          check_confluence_config
+          check_editor_config
+        end
+
+        def check_confluence_config
+          config = Aircana.configuration
+
+          if confluence_configured?(config)
+            log_success("Confluence", "API credentials configured")
+          else
+            log_info("Confluence", "Not configured")
+            log_remedy("Set CONFLUENCE_BASE_URL, CONFLUENCE_USERNAME, " \
+                       "and CONFLUENCE_API_TOKEN for agent knowledge refresh")
+          end
+        end
+
+        def check_editor_config
+          editor = ENV.fetch("EDITOR", nil)
+          available_editors = find_available_editors
+
+          handle_editor_status(editor, available_editors)
+        end
+
+        def handle_editor_status(editor, available_editors)
+          if editor && command_available?(editor)
+            log_success("Editor", "EDITOR set to #{editor}")
+          elsif !available_editors.empty?
+            log_info("Editor", "Available editors: #{available_editors.join(", ")}")
+            log_remedy("Set EDITOR environment variable to prefer one")
+          else
+            log_warning("Editor", "No common editors found")
+            log_remedy("Install an editor or set EDITOR environment variable")
+          end
+        end
+      end
+    end
+  end
+end