aircana 4.0.0.rc1 → 4.0.0.rc3

data/commands/plan.md

@@ -1,33 +0,0 @@
-INSTRUCTIONS : First, ask the user to specify relevant files, directories, or areas of the codebase to examine for this planning task.
-
-Then use the Task tool with subagent_type 'planner' to invoke the planner agent with the following explicit instructions:
-
-STEP 1: CREATE TODO LIST FILE
-First, create a todo list file with the following tasks enumerated in order:
-
-1. Ask user for relevant files and context (if not already provided)
-2. Use Task tool with subagent_type 'jira' to verify Jira ticket information (or ask user to create/provide ticket)
-3. Perform targeted initial research on user-specified files
-4. Consult relevant sub-agents with research context (run in parallel when possible)
-5. Create high-level strategic implementation plan
-6. Iterate with user feedback
-7. Suggest user runs '/air-record' command to save the plan to Jira ticket
-
-STEP 2: EXECUTE EACH TASK IN ORDER
-Work through each task in the todo list sequentially:
-- Mark each task as 'in_progress' when you start it
-- Mark each task as 'completed' when finished
-- Continue until all tasks are done
-
-IMPORTANT CONTEXT-SHARING PROTOCOL:
-- When consulting sub-agents, explicitly provide: files already searched, files already read, key findings, and specific focus area
-- This prevents sub-agents from duplicating research work
-
-IMPORTANT PLAN CONSTRAINTS:
-- Focus on strategic, high-level implementation guidance
-- NO rollout plans, effort estimates, or exhaustive code implementations
-- Small code examples (5-10 lines) are OK to illustrate concepts
-
-User specified relevant files/areas: [User will specify]
-
-Ask the user to provide a Jira ticket or task description.

data/commands/record.md

@@ -1,17 +0,0 @@
-INSTRUCTIONS : Use the Task tool with subagent_type 'jira' to append the implementation plan to the Jira ticket description using Jira MCP tools.
-
-INSTRUCTIONS FOR JIRA AGENT:
-1. Read the implementation plan from the current context (look for recent planning output)
-2. Get the current ticket description using mcp__jira__getJiraIssue with fields=["description"]
-3. Append the plan to the existing description under a new "## Implementation Plan" heading
-4. Update the ticket using mcp__jira__editJiraIssue with the combined description
-5. Format the appended plan section with:
-   - Consulted sub-agents
-   - Relevant files analyzed
-   - Planning timestamp
-   - Implementation steps as todo list using `[ ]` format
-6. Provide the ticket URL for easy access
-
-CRITICAL: The jira sub-agent must append to the ticket description using mcp__jira__editJiraIssue (NOT create files or comments).
-
-IMPORTANT: Delegate all Jira operations to the 'jira' sub-agent using Task tool with subagent_type 'jira'. The Jira ticket key/ID is already in context.

data/commands/review.md

@@ -1,12 +0,0 @@
-INSTRUCTIONS : Use the Task tool with subagent_type 'reviewer' to conduct an adversarial code review of the HEAD commit.
-
-The reviewer agent will:
-1. Get HEAD commit details and changes
-2. Analyze changed files to identify technical domains
-3. Use the sub-agent-coordinator to select relevant expert agents
-4. Present changes to experts in parallel for review
-5. Synthesize feedback organized by severity
-6. Store review output for the apply-feedback command
-7. Suggest running '/air-apply-feedback' to apply recommended changes
-
-IMPORTANT: The review agent will automatically review the HEAD commit. No arguments needed.

data/hooks/hooks.json

@@ -1,31 +0,0 @@
-{
-  "PostToolUse": [
-    {
-      "hooks": [
-        {
-          "type": "command",
-          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_use.sh"
-        }
-      ]
-    }
-  ],
-  "PreToolUse": [
-    {
-      "hooks": [
-        {
-          "type": "command",
-          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre_tool_use.sh"
-        }
-      ]
-    },
-    {
-      "hooks": [
-        {
-          "type": "command",
-          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/rubocop_pre_commit.sh"
-        }
-      ],
-      "matcher": "Bash"
-    }
-  ]
-}

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

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "tty-prompt"
-require_relative "../../generators/hooks_generator"
-require_relative "init"
-
-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
-          Init.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
-          Init.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
-          Init.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