ace-support-core 0.29.0

data/lib/ace/core/molecules/prompt_cache_manager.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "ace/support/fs"
+require "fileutils"
+require "yaml"
+
+module Ace
+  module Core
+    module Molecules
+      # Standardized prompt cache management for ace-* gems
+      # Provides consistent session directory creation, prompt saving, and metadata management
+      #
+      # This is a stateless utility class - all methods are class methods.
+      class PromptCacheManager
+        # Custom exception for prompt cache operations
+        class PromptCacheError < StandardError; end
+        class << self
+          # Create a new session directory with standardized structure
+          # @param gem_name [String] Name of the gem (e.g., 'ace-review', 'ace-docs')
+          # @param operation [String] Operation name (e.g., 'review', 'analyze-consistency')
+          # @param project_root [String, nil] Optional project root (auto-detected if nil)
+          # @param timestamp_formatter [Proc, nil] Optional custom timestamp formatter
+          # @return [String] Path to created session directory
+          def create_session(gem_name, operation, project_root: nil, timestamp_formatter: nil)
+            raise ArgumentError, "gem_name cannot be nil or empty" if gem_name.nil? || gem_name.strip.empty?
+            raise ArgumentError, "operation cannot be nil or empty" if operation.nil? || operation.strip.empty?
+
+            begin
+              root = project_root || Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+              timestamp = timestamp_formatter ? timestamp_formatter.call(Time.now) : Time.now.strftime("%Y%m%d-%H%M%S")
+              session_name = "#{operation}-#{timestamp}"
+              session_dir = File.join(base_cache_path(root, gem_name), session_name)
+              FileUtils.mkdir_p(session_dir)
+              session_dir
+            rescue Errno::ENOENT, Errno::EACCES => e
+              raise PromptCacheError, "Failed to create session directory: #{e.message}"
+            rescue => e
+              raise PromptCacheError, "Unexpected error creating session: #{e.message}"
+            end
+          end
+
+          # Save system prompt to session directory
+          # @param content [String] Prompt content
+          # @param session_dir [String] Session directory path
+          # @return [String] Path to saved file
+          def save_system_prompt(content, session_dir)
+            save_prompt(content, session_dir, "system.prompt.md")
+          end
+
+          # Save user prompt to session directory
+          # @param content [String] Prompt content
+          # @param session_dir [String] Session directory path
+          # @return [String] Path to saved file
+          def save_user_prompt(content, session_dir)
+            save_prompt(content, session_dir, "user.prompt.md")
+          end
+
+          # Save metadata to session directory
+          # @param metadata [Hash] Metadata hash
+          # @param session_dir [String] Session directory path
+          # @param validate [Boolean] Whether to validate metadata schema (default: true)
+          # @return [String] Path to saved file
+          def save_metadata(metadata, session_dir, validate: true)
+            raise ArgumentError, "metadata must be a Hash" unless metadata.is_a?(Hash)
+            raise ArgumentError, "session_dir cannot be nil or empty" if session_dir.nil? || session_dir.strip.empty?
+
+            validate_metadata(metadata) if validate
+
+            begin
+              metadata_path = File.join(session_dir, "metadata.yml")
+              File.write(metadata_path, YAML.dump(metadata))
+              metadata_path
+            rescue Errno::ENOENT, Errno::EACCES => e
+              raise PromptCacheError, "Failed to save metadata to #{metadata_path}: #{e.message}"
+            rescue => e
+              raise PromptCacheError, "Unexpected error saving metadata: #{e.message}"
+            end
+          end
+
+          # Validate metadata schema
+          # @param metadata [Hash] Metadata hash to validate
+          # @raise [ArgumentError] If required fields are missing
+          def validate_metadata(metadata)
+            required_fields = %w[timestamp gem operation]
+            missing = required_fields - metadata.keys
+            unless missing.empty?
+              raise ArgumentError, "Missing required metadata fields: #{missing.join(", ")}"
+            end
+
+            # Validate field types
+            unless metadata["timestamp"].is_a?(String) || metadata["timestamp"].is_a?(Time)
+              raise ArgumentError, "Metadata 'timestamp' must be a String or Time"
+            end
+
+            unless metadata["gem"].is_a?(String) && !metadata["gem"].strip.empty?
+              raise ArgumentError, "Metadata 'gem' must be a non-empty String"
+            end
+
+            unless metadata["operation"].is_a?(String) && !metadata["operation"].strip.empty?
+              raise ArgumentError, "Metadata 'operation' must be a non-empty String"
+            end
+          end
+
+          private
+
+          # Get base cache path for a gem
+          # @param project_root [String] Project root path
+          # @param gem_name [String] Name of the gem
+          # @return [String] Base cache path (.ace-local/{short-gem}/sessions/)
+          def base_cache_path(project_root, gem_name)
+            short_name = gem_name.to_s.sub(/\Aace-/, "")
+            cache_path = File.join(project_root, ".ace-local", short_name, "sessions")
+            FileUtils.mkdir_p(cache_path) unless Dir.exist?(cache_path)
+            cache_path
+          end
+
+          # Save a prompt file
+          # @param content [String] Prompt content
+          # @param session_dir [String] Session directory path
+          # @param filename [String] Filename for the prompt
+          # @return [String] Path to saved file
+          def save_prompt(content, session_dir, filename)
+            raise ArgumentError, "content cannot be nil" if content.nil?
+            raise ArgumentError, "session_dir cannot be nil or empty" if session_dir.nil? || session_dir.strip.empty?
+            raise ArgumentError, "filename cannot be nil or empty" if filename.nil? || filename.strip.empty?
+
+            begin
+              prompt_path = File.join(session_dir, filename)
+              File.write(prompt_path, content)
+              prompt_path
+            rescue Errno::ENOENT, Errno::EACCES => e
+              raise PromptCacheError, "Failed to save prompt to #{prompt_path}: #{e.message}"
+            rescue => e
+              raise PromptCacheError, "Unexpected error saving prompt: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/organisms/config_diff.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+require_relative "../models/config_templates"
+
+module Ace
+  module Core
+    class ConfigDiff
+      def initialize(global: false, file: nil, one_line: false)
+        @global = global
+        @file = file
+        @one_line = one_line
+        @diffs = []
+      end
+
+      def run
+        if @file
+          diff_file(@file)
+        else
+          diff_all_configs
+        end
+
+        print_results
+      end
+
+      def diff_gem(gem_name)
+        # Normalize gem name (support both "ace-bundle" and "bundle")
+        gem_name = gem_name.start_with?("ace-") ? gem_name : "ace-#{gem_name}"
+
+        unless ConfigTemplates.gem_exists?(gem_name)
+          puts "Error: Gem '#{gem_name}' not found or has no example configurations"
+          exit 1
+        end
+
+        diff_gem_configs(gem_name)
+        print_results
+      end
+
+      private
+
+      def config_directory
+        @global ? File.expand_path("~/.ace") : ".ace"
+      end
+
+      def diff_all_configs
+        ConfigTemplates.all_gems.each do |gem_name|
+          diff_gem_configs(gem_name)
+        end
+      end
+
+      def diff_gem_configs(gem_name)
+        source_dir = ConfigTemplates.example_dir_for(gem_name)
+
+        return unless source_dir && File.exist?(source_dir)
+
+        Dir.glob("#{source_dir}/**/*").each do |source_file|
+          next if File.directory?(source_file)
+
+          relative_path = Pathname.new(source_file).relative_path_from(Pathname.new(source_dir))
+          target_file = File.join(config_directory, relative_path.to_s)
+
+          compare_files(source_file, target_file, gem_name)
+        end
+      end
+
+      def diff_file(file_path)
+        # Determine which gem this file belongs to
+        if file_path.start_with?(config_directory)
+          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(config_directory))
+          parts = relative_path.to_s.split(File::SEPARATOR)
+
+          if parts.any?
+            config_subdir = parts.first
+            gem_name = "ace-#{config_subdir}"
+
+            if ConfigTemplates.gem_exists?(gem_name)
+              source_dir = ConfigTemplates.example_dir_for(gem_name)
+              relative_file = parts[1..-1].join(File::SEPARATOR)
+              source_file = File.join(source_dir, relative_file)
+
+              if File.exist?(source_file)
+                compare_files(source_file, file_path, gem_name)
+              else
+                puts "No example file found for #{file_path}"
+              end
+            end
+          end
+        else
+          puts "File #{file_path} is not in a configuration directory"
+        end
+      end
+
+      def compare_files(source_file, target_file, gem_name)
+        @diffs << if !File.exist?(target_file)
+          {
+            gem: gem_name,
+            file: target_file,
+            status: :missing,
+            source: source_file
+          }
+        elsif files_differ?(source_file, target_file)
+          {
+            gem: gem_name,
+            file: target_file,
+            status: :different,
+            source: source_file,
+            diff_output: get_diff_output(source_file, target_file)
+          }
+        else
+          {
+            gem: gem_name,
+            file: target_file,
+            status: :same,
+            source: source_file
+          }
+        end
+      end
+
+      def files_differ?(file1, file2)
+        File.read(file1) != File.read(file2)
+      rescue
+        true
+      end
+
+      def get_diff_output(source_file, target_file)
+        # Use system diff command
+        output, _status = Open3.capture2("diff", "-u", target_file, source_file)
+        output
+      rescue
+        "Unable to generate diff"
+      end
+
+      def print_results
+        if @one_line
+          print_one_line_summary
+        else
+          print_detailed_diffs
+        end
+      end
+
+      def print_one_line_summary
+        @diffs.each do |diff|
+          case diff[:status]
+          when :missing
+            puts "MISSING: #{diff[:file]}"
+          when :different
+            puts "CHANGED: #{diff[:file]}"
+          when :same
+            puts "SAME:    #{diff[:file]}" if @verbose
+          end
+        end
+
+        puts "\nSummary:"
+        puts "  Missing: #{@diffs.count { |d| d[:status] == :missing }}"
+        puts "  Changed: #{@diffs.count { |d| d[:status] == :different }}"
+        puts "  Same: #{@diffs.count { |d| d[:status] == :same }}"
+      end
+
+      def print_detailed_diffs
+        missing = @diffs.select { |d| d[:status] == :missing }
+        changed = @diffs.select { |d| d[:status] == :different }
+
+        if missing.any?
+          puts "Missing configuration files:"
+          missing.each do |diff|
+            puts "  #{diff[:file]}"
+            puts "  -> Example: #{diff[:source]}"
+          end
+          puts
+        end
+
+        if changed.any?
+          puts "Changed configuration files:"
+          changed.each do |diff|
+            puts "\n#{diff[:file]}:"
+            puts diff[:diff_output]
+          end
+        end
+
+        if missing.empty? && changed.empty?
+          puts "All configuration files match the examples."
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/organisms/config_initializer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "../models/config_templates"
+
+module Ace
+  module Core
+    class ConfigInitializer
+      def initialize(force: false, dry_run: false, global: false, verbose: false)
+        @force = force
+        @dry_run = dry_run
+        @global = global
+        @verbose = verbose
+        @copied_files = []
+        @skipped_files = []
+      end
+
+      def init_all
+        puts "Initializing all ace-* gem configurations..." if @verbose
+
+        ConfigTemplates.all_gems.each do |gem_name|
+          init_gem(gem_name)
+        end
+
+        print_summary
+      end
+
+      def init_gem(gem_name)
+        gem_name = normalize_gem_name(gem_name)
+
+        unless ConfigTemplates.gem_exists?(gem_name)
+          puts "Warning: No configuration found for #{gem_name}"
+          return
+        end
+
+        puts "\nInitializing #{gem_name}..." if @verbose
+
+        source_dir = ConfigTemplates.example_dir_for(gem_name)
+        target_dir = target_directory
+
+        unless File.exist?(source_dir)
+          puts "Warning: No .ace-defaults directory found for #{gem_name}"
+          return
+        end
+
+        # Show config docs on first run if config is missing
+        show_config_docs_if_needed(gem_name, target_dir)
+
+        # Copy files from .ace-defaults to .ace
+        copy_config_files(source_dir, target_dir, gem_name)
+      end
+
+      private
+
+      def normalize_gem_name(name)
+        # Handle both "ace-core" and "core" formats
+        name.start_with?("ace-") ? name : "ace-#{name}"
+      end
+
+      def target_directory
+        @global ? File.expand_path("~/.ace") : ".ace"
+      end
+
+      def show_config_docs_if_needed(gem_name, target_dir)
+        # Check if any config files exist for this gem
+        config_subdir = gem_name.sub("ace-", "")
+
+        # Look for any existing config files in the expected location
+        existing_configs = Dir.glob("#{target_dir}/#{config_subdir}/**/*").reject { |f| File.directory?(f) }
+
+        # Only show docs if this is the first time (no existing config)
+        if existing_configs.empty? && !@dry_run
+          docs_file = ConfigTemplates.docs_file_for(gem_name)
+          if File.exist?(docs_file)
+            puts "\n#{File.read(docs_file)}\n"
+          end
+        end
+      end
+
+      def copy_config_files(source_dir, target_dir, gem_name)
+        Dir.glob("#{source_dir}/**/*").each do |source_file|
+          next if File.directory?(source_file)
+
+          # Calculate relative path from source_dir
+          relative_path = Pathname.new(source_file).relative_path_from(Pathname.new(source_dir))
+
+          # Build target path - files already include their subdirectory
+          target_file = File.join(target_dir, relative_path.to_s)
+
+          copy_file(source_file, target_file)
+        end
+      end
+
+      def copy_file(source, target)
+        if File.exist?(target) && !@force
+          @skipped_files << target
+          puts "  Skipped: #{target} (already exists)" if @verbose
+          return
+        end
+
+        if @dry_run
+          puts "  Would copy: #{source} -> #{target}"
+        else
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.cp(source, target)
+          @copied_files << target
+          puts "  Copied: #{target}" if @verbose
+        end
+      end
+
+      def print_summary
+        return if @dry_run
+
+        puts "\nConfiguration initialization complete:"
+        puts "  Files copied: #{@copied_files.size}"
+        puts "  Files skipped: #{@skipped_files.size}"
+
+        if @skipped_files.any? && !@force
+          puts "\nUse --force to overwrite existing files"
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/organisms/environment_manager.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "../molecules/env_loader"
+require "ace/support/config"
+require "ace/support/fs"
+
+module Ace
+  module Core
+    module Organisms
+      # Complete environment variable management
+      class EnvironmentManager
+        attr_reader :root_path, :config
+
+        # Initialize environment manager
+        # @param root_path [String] Project root path
+        # @param config [Models::Config, nil] Configuration to use
+        def initialize(root_path: Dir.pwd, config: nil)
+          @root_path = Ace::Support::Fs::Atoms::PathExpander.expand(root_path)
+          @config = config || load_config
+        end
+
+        # Load environment variables based on configuration
+        # @param overwrite [Boolean] Whether to overwrite existing vars
+        # @return [Hash] Variables that were loaded
+        def load
+          return {} unless should_load_dotenv?
+
+          dotenv_files = get_dotenv_files
+          loaded_vars = {}
+
+          dotenv_files.each do |file|
+            filepath = resolve_dotenv_path(file)
+            next unless filepath
+
+            vars = Molecules::EnvLoader.load_file(filepath)
+            loaded_vars.merge!(vars) if vars && !vars.empty?
+          end
+
+          # Set all loaded variables
+          Molecules::EnvLoader.set_environment(loaded_vars, overwrite: false)
+        end
+
+        # Save current environment to .env file
+        # @param filepath [String] Path to save to
+        # @param keys [Array<String>] Specific keys to save (nil = all)
+        # @return [Hash] Variables that were saved
+        def save(filepath = ".env", keys: nil)
+          filepath = File.join(root_path, filepath) unless Ace::Support::Fs::Atoms::PathExpander.absolute?(filepath)
+
+          vars_to_save = if keys
+            ENV.to_h.select { |k, _| keys.include?(k) }
+          else
+            ENV.to_h
+          end
+
+          Molecules::EnvLoader.save_file(vars_to_save, filepath)
+          vars_to_save
+        end
+
+        # Get specific environment variable with fallback
+        # @param key [String] Variable name
+        # @param default [Object] Default value if not found
+        # @return [String, Object] Variable value or default
+        def get(key, default = nil)
+          ENV.fetch(key, default)
+        end
+
+        # Set environment variable
+        # @param key [String] Variable name
+        # @param value [String] Variable value
+        # @return [String] The value that was set
+        def set(key, value)
+          ENV[key] = value.to_s
+        end
+
+        # Check if variable exists
+        # @param key [String] Variable name
+        # @return [Boolean] true if variable exists
+        def key?(key)
+          ENV.key?(key)
+        end
+
+        # List all .env files that would be loaded
+        # @return [Array<String>] Paths to .env files
+        def list_dotenv_files
+          return [] unless should_load_dotenv?
+
+          dotenv_files = get_dotenv_files
+          dotenv_files.map { |file| resolve_dotenv_path(file) }.compact
+        end
+
+        private
+
+        # Load configuration
+        # @return [Models::Config] Configuration
+        def load_config
+          resolver = ::Ace::Support::Config.create(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults"
+          )
+          resolver.resolve
+        end
+
+        # Check if dotenv should be loaded
+        # @return [Boolean] true if should load
+        def should_load_dotenv?
+          config.get("ace", "environment", "load_dotenv") != false
+        end
+
+        # Get list of dotenv files from config
+        # @return [Array<String>] Dotenv file names
+        def get_dotenv_files
+          files = config.get("ace", "environment", "dotenv_files")
+          return [".env.local", ".env"] if files.nil?
+
+          files.is_a?(Array) ? files : [files]
+        end
+
+        # Resolve dotenv file path
+        # @param filename [String] Dotenv filename
+        # @return [String, nil] Full path if exists
+        def resolve_dotenv_path(filename)
+          # Try as absolute path first
+          if Ace::Support::Fs::Atoms::PathExpander.absolute?(filename)
+            expanded = Ace::Support::Fs::Atoms::PathExpander.expand(filename)
+            return expanded if File.exist?(expanded)
+          end
+
+          # Try relative to root
+          filepath = File.join(root_path, filename)
+          return filepath if File.exist?(filepath)
+
+          # Try in .ace directory
+          filepath = File.join(root_path, ".ace", filename)
+          return filepath if File.exist?(filepath)
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ace
+  module Core
+    VERSION = "0.29.0"
+  end
+end