aircana 0.1.0 → 1.1.0.rc1

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,158 @@
+# 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
+
+      # Helper methods for resolving symlinked agent paths
+      def resolve_agent_path(agent_name)
+        agent_path = File.join(Aircana.configuration.agent_knowledge_dir, agent_name)
+
+        if File.symlink?(agent_path)
+          File.readlink(agent_path)
+        else
+          agent_path
+        end
+      end
+
+      def agent_is_symlinked?(agent_name)
+        agent_path = File.join(Aircana.configuration.agent_knowledge_dir, agent_name)
+        File.symlink?(agent_path)
+      end
+
+      def resolve_symlinked_path(path)
+        File.symlink?(path) ? File.readlink(path) : path
+      end
+    end
+  end
+end

data/lib/aircana/system_checker.rb

@@ -23,6 +23,16 @@ module Aircana
           "Arch" => "pacman -S git",
           "Other" => "https://git-scm.com/downloads"
         }
+      },
+      "jq" => {
+        purpose: "JSON parsing for multi-root configuration",
+        install: {
+          "macOS" => "brew install jq",
+          "Ubuntu/Debian" => "apt install jq",
+          "Fedora/CentOS" => "dnf install jq",
+          "Arch" => "pacman -S jq",
+          "Other" => "https://jqlang.github.io/jq/download/"
+        }
       }
     }.freeze
 

data/lib/aircana/templates/hooks/bundle_install.erb

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Bundle install hook generated by Aircana
+# This hook runs bundle install when Gemfile changes are detected
+
+# Get the tool details
+TOOL_NAME="$1"
+TOOL_PARAMS="$2"
+
+# Only act on file modification tools
+case "$TOOL_NAME" in
+  "Edit"|"Write"|"MultiEdit")
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# Check if Gemfile was modified
+if ! echo "$TOOL_PARAMS" | grep -q "Gemfile"; then
+  exit 0
+fi
+
+# Check if this is a Ruby project
+if [ ! -f "Gemfile" ]; then
+  exit 0
+fi
+
+echo "Gemfile modified, running bundle install..."
+
+# Run bundle install
+if command -v bundle >/dev/null 2>&1; then
+  bundle install
+  BUNDLE_EXIT_CODE=$?
+
+  if [ $BUNDLE_EXIT_CODE -eq 0 ]; then
+    cat << EOF
+{
+      "type": "advanced",
+      "decision": "allow",
+      "message": "Bundle install completed successfully after Gemfile modification."
+    }
+EOF
+  else
+    cat << EOF
+{
+      "type": "advanced",
+      "decision": "allow",
+      "message": "Bundle install failed. You may need to run 'bundle install' manually.\n\nError code: $BUNDLE_EXIT_CODE"
+    }
+EOF
+  fi
+else
+  cat << EOF
+{
+    "type": "advanced",
+    "decision": "allow",
+    "message": "Bundler not found. Please install bundler and run 'bundle install' manually."
+  }
+EOF
+fi
+
+# Always allow the modification to proceed
+exit 0

data/lib/aircana/templates/hooks/post_tool_use.erb

@@ -0,0 +1,49 @@
+#!/bin/bash
+# Post-tool-use hook generated by Aircana
+# This hook runs after a tool has been executed
+
+# Get tool execution details
+TOOL_NAME="$1"
+TOOL_PARAMS="$2"
+TOOL_RESULT="$3"
+EXIT_CODE="$4"
+
+# Log the tool execution
+echo "$(date): Tool '$TOOL_NAME' completed with exit code: $EXIT_CODE" >> ~/.aircana/hooks.log
+
+# Initialize context for response
+ADDITIONAL_CONTEXT=""
+
+# Handle specific tools
+case "$TOOL_NAME" in
+  "Edit"|"Write")
+    # Auto-update relevant files context if code files were modified
+    if echo "$TOOL_PARAMS" | grep -E "\.(rb|js|py|ts)$" && [ "$EXIT_CODE" -eq 0 ]; then
+      ADDITIONAL_CONTEXT="Code file modified - consider updating relevant files context."
+    fi
+    ;;
+  "Bash")
+    # Handle bash command results
+    if [ "$EXIT_CODE" -ne 0 ]; then
+      echo "Bash command failed: $TOOL_PARAMS" >> ~/.aircana/hooks.log
+      ADDITIONAL_CONTEXT="Previous bash command failed with exit code $EXIT_CODE."
+    fi
+    ;;
+esac
+
+# Output appropriate JSON response
+if [ -n "$ADDITIONAL_CONTEXT" ]; then
+  # Escape context for JSON
+  ESCAPED_CONTEXT=$(echo -n "$ADDITIONAL_CONTEXT" | sed 's/"/\\"/g')
+  cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PostToolUse",
+    "additionalContext": "$ESCAPED_CONTEXT"
+  }
+}
+EOF
+else
+  # No additional context needed
+  echo "{}"
+fi

data/lib/aircana/templates/hooks/pre_tool_use.erb

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Pre-tool-use hook generated by Aircana
+# This hook runs before any tool is executed
+
+# Get the tool name and parameters
+TOOL_NAME="$1"
+TOOL_PARAMS="$2"
+
+# Log the tool usage (optional)
+echo "$(date): About to use tool: $TOOL_NAME" >> ~/.aircana/hooks.log
+
+# Basic validation example
+case "$TOOL_NAME" in
+  "Bash")
+    # Add validation for bash commands
+    if echo "$TOOL_PARAMS" | grep -q "rm -rf /"; then
+      cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "Dangerous command detected: rm -rf /"
+  }
+}
+EOF
+      exit 0
+    fi
+    ;;
+  "Edit"|"Write")
+    # Validate file operations
+    # Add custom validation logic here
+    ;;
+esac
+
+# Allow the tool to proceed
+cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "allow"
+  }
+}
+EOF

data/lib/aircana/templates/hooks/rspec_test.erb

@@ -0,0 +1,72 @@
+#!/bin/bash
+# RSpec test hook generated by Aircana
+# This hook runs relevant tests when Ruby files are modified
+
+# Get the tool details
+TOOL_NAME="$1"
+TOOL_PARAMS="$2"
+
+# Only act on file modification tools
+case "$TOOL_NAME" in
+  "Edit"|"Write"|"MultiEdit")
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# Check if this is a Ruby project with RSpec
+if [ ! -f "Gemfile" ] || ! grep -q "rspec" Gemfile 2>/dev/null; then
+  exit 0
+fi
+
+# Extract file path from tool parameters (basic extraction)
+MODIFIED_FILE=$(echo "$TOOL_PARAMS" | grep -o '"[^"]*\.rb"' | head -1 | tr -d '"')
+
+if [ -z "$MODIFIED_FILE" ]; then
+  exit 0
+fi
+
+# Determine which specs to run based on the modified file
+SPEC_FILE=""
+
+# Check for corresponding spec file
+if echo "$MODIFIED_FILE" | grep -q "^lib/"; then
+  # For lib files, look for spec file
+  SPEC_FILE="spec/$(echo "$MODIFIED_FILE" | sed 's|^lib/||' | sed 's|\.rb$|_spec.rb|')"
+elif echo "$MODIFIED_FILE" | grep -q "^app/"; then
+  # For Rails app files
+  SPEC_FILE="spec/$(echo "$MODIFIED_FILE" | sed 's|^app/||' | sed 's|\.rb$|_spec.rb|')"
+elif echo "$MODIFIED_FILE" | grep -q "_spec\.rb$"; then
+  # If the modified file is already a spec file
+  SPEC_FILE="$MODIFIED_FILE"
+fi
+
+# Check if spec file exists
+if [ -n "$SPEC_FILE" ] && [ -f "$SPEC_FILE" ]; then
+  echo "Running tests for modified file: $MODIFIED_FILE"
+
+  # Run the specific test
+  if command -v bundle >/dev/null 2>&1; then
+    bundle exec rspec "$SPEC_FILE" --format progress
+  else
+    rspec "$SPEC_FILE" --format progress
+  fi
+
+  RSPEC_EXIT_CODE=$?
+
+  if [ $RSPEC_EXIT_CODE -ne 0 ]; then
+    cat << EOF
+{
+  "type": "advanced",
+  "decision": "allow",
+  "message": "Tests failed for $SPEC_FILE. Consider fixing the failing tests.\n\nYou can run: bundle exec rspec $SPEC_FILE"
+}
+EOF
+  else
+    echo "Tests passed for $SPEC_FILE"
+  fi
+fi
+
+# Always allow the modification to proceed
+exit 0

data/lib/aircana/templates/hooks/rubocop_pre_commit.erb

@@ -0,0 +1,55 @@
+#!/bin/bash
+# RuboCop pre-commit hook generated by Aircana
+# This hook runs RuboCop before allowing commits
+
+# Get the tool name and parameters
+TOOL_NAME="$1"
+TOOL_PARAMS="$2"
+
+# Only act on Bash commands that look like git commits
+if [ "$TOOL_NAME" != "Bash" ]; then
+  exit 0
+fi
+
+# Check if this is a git commit command
+if ! echo "$TOOL_PARAMS" | grep -q "git commit"; then
+  exit 0
+fi
+
+# Check if we're in a Ruby project
+if [ ! -f "Gemfile" ] && [ ! -f ".rubocop.yml" ]; then
+  exit 0
+fi
+
+# Get list of staged Ruby files
+RUBY_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(rb)$' | tr '\n' ' ')
+
+if [ -z "$RUBY_FILES" ]; then
+  # No Ruby files to check
+  exit 0
+fi
+
+echo "Running RuboCop on staged Ruby files..."
+
+# Run RuboCop on staged files
+if command -v bundle >/dev/null 2>&1 && [ -f "Gemfile" ]; then
+  bundle exec rubocop $RUBY_FILES
+else
+  rubocop $RUBY_FILES
+fi
+
+RUBOCOP_EXIT_CODE=$?
+
+if [ $RUBOCOP_EXIT_CODE -ne 0 ]; then
+  cat << EOF
+{
+  "type": "advanced",
+  "decision": "deny",
+  "message": "RuboCop found style violations. Please fix them before committing.\n\nYou can run: bundle exec rubocop $RUBY_FILES --auto-correct\n\nOr fix them manually and try again."
+}
+EOF
+  exit 1
+fi
+
+# RuboCop passed, allow the commit
+exit 0