parabot 1.0.0

data/lib/parabot/commands/init.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+require_relative "../yaml_text_assembler"
+require_relative "../language_inference"
+require_relative "../logging_setup"
+
+module Parabot
+  module Commands
+    class Init < Base
+      desc "Initialize a new Parabot project with default configuration"
+
+      option :force, type: :boolean, default: false, desc: "Overwrite existing .parabot.yml file"
+
+      def call(**options)
+        init(**options)
+
+        # Setup logging using the same configuration as normal operation, with defaults
+        LoggingSetup.setup_default
+
+        initialize_project_config
+        initialize_system_prompt
+      end
+
+      private
+
+      def initialize_project_config
+        target_file = Parabot::System.determine_system_path(".parabot.yml", options[:project_root])
+
+        target_dir = File.dirname(target_file)
+        unless Dir.exist?(target_dir)
+          logger.error("Target directory doesnt exist: #{target_dir}")
+          raise Parabot::Error, "Target directory for configuration does not exist"
+        end
+
+        # Check if target already exists
+        if File.exist?(target_file) && !options[:force]
+          logger.error("Configuration file #{target_file} already exists")
+          logger.info("Use --force to overwrite existing configuration")
+          raise Parabot::Error, "Configuration file already exists"
+        end
+
+        # Detect languages for this project
+        languages = detect_language
+        supported, unsupported = YamlTextAssembler.partition_language_support(languages)
+
+        # Provide user feedback about language support
+        if unsupported.any?
+          logger.info("Detected languages: #{languages.join(', ')}")
+          logger.info("Full support: #{supported.join(', ')}") if supported.any?
+          logger.info("Minimal support: #{unsupported.join(', ')}") if unsupported.any?
+        elsif supported.any?
+          logger.info("All detected languages have full support: #{supported.join(', ')}")
+        end
+
+        dry_run_log "Would create targeted configuration for languages: #{languages.join(', ')}"
+        dry_run_log "Target file: #{target_file}"
+        return if dry_run?
+
+        begin
+          # Assemble targeted configuration as clean YAML text
+          yaml_content = YamlTextAssembler.assemble_for_languages(languages)
+
+          # Add header comment to generated file
+          config_with_header = build_config_header(languages, supported, unsupported) + yaml_content
+
+          File.write(target_file, config_with_header)
+
+          # Provide success feedback
+          action = File.exist?(target_file) && options[:force] ? "Overwrote" : "Created"
+          logger.info("#{action} #{target_file} with configuration for: #{languages.join(', ')}")
+
+          logger.info("Languages with minimal support: #{unsupported.join(', ')}") if unsupported.any?
+        rescue SystemCallError => e
+          logger.error("Failed to initialize configuration: #{e.message}")
+          raise e
+        end
+      end
+
+      def initialize_system_prompt
+        target_file = Parabot::System.determine_system_path(".parabot.md", options[:project_root])
+
+        target_dir = File.dirname(target_file)
+        unless Dir.exist?(target_dir)
+          logger.error("Target directory doesnt exist: #{target_dir}")
+          raise Parabot::Error, "Target directory for system prompt does not exist"
+        end
+
+        # Check if target already exists
+        if File.exist?(target_file) && !options[:force]
+          logger.error("System prompt file #{target_file} already exists")
+          logger.info("Use --force to overwrite existing file")
+          raise Parabot::Error, "System prompt file already exists"
+        end
+
+        languages = detect_language
+        dry_run_log "Detected languages: #{languages.join(', ')}"
+        dry_run_log "Would write system prompt to #{target_file}"
+
+        # Get system prompt directly from source files, not from config that doesn't exist yet
+        prompt = build_system_prompt_for_languages(languages)
+        dry_run_log "System prompt:"
+        dry_run_log prompt
+
+        return if dry_run?
+
+        begin
+          File.write(target_file, prompt)
+
+          # Provide success feedback
+          action = File.exist?(target_file) && options[:force] ? "Overwrote" : "Created"
+          logger.info("#{action} #{target_file} with system prompt for #{languages.join(', ')}")
+
+        rescue SystemCallError => e
+          logger.error("Failed to initialize system prompt: #{e.message}")
+          raise e
+        end
+      end
+
+      def build_config_header(languages, supported, unsupported)
+        header = "# Generated configuration for: #{languages.join(', ')}\n"
+        header += "# \n"
+
+        if unsupported.any?
+          header += "# ⚠️  Languages with minimal support: #{unsupported.join(', ')}\n"
+          header += "# These languages use basic TDD guidance only.\n"
+          header += "# Consider contributing full language support at:\n"
+          header += "# https://github.com/AlexParamonov/parabot#contributing-language-support\n"
+          header += "#\n"
+        end
+
+        header += "# This file was generated by: parabot init\n"
+        header += "# Detected languages: #{languages.join(', ')}\n"
+        header += "# Full support: #{supported.join(', ')}\n" if supported.any?
+        header += "# Minimal support: #{unsupported.join(', ')}\n" if unsupported.any?
+        header += "\n"
+
+        header
+      end
+
+      def detect_language
+        if options[:language].any?
+          options[:language]
+        else
+          # Delegate to LanguageDetector with all languages loaded
+          LanguageDetector.detect_with_all_languages(options[:project_root] || ".")
+        end
+      end
+
+      def build_system_prompt_for_languages(languages)
+        # Read base system prompt
+        config_dir = File.join(__dir__, "../../../config")
+        base_content = File.read(File.join(config_dir, "core_prompts/system_prompt.yml"))
+        parsed = YAML.load(base_content)
+        base_prompt = parsed["system_prompt"]
+
+        # Add language-specific prompts
+        languages.map(&:to_s).each do |lang|
+          lang_file = File.join(config_dir, "languages/#{lang}.yml")
+          next unless File.exist?(lang_file)
+
+          lang_config = YAML.load_file(lang_file)
+          base_prompt += "\n\n#{lang_config['system_prompt']}" if lang_config["system_prompt"]
+        end
+
+        base_prompt
+      end
+    end
+  end
+end

data/lib/parabot/commands/message.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Commands
+    class Message < Base
+      desc "Send a message to Claude"
+
+      argument :message, required: true, desc: "Message to send to Claude"
+
+      def call(message:, **options)
+        init(**options)
+
+        @message = message
+
+        send_message(message)
+      rescue TmuxError => e
+        logger.error("Failed to send message: #{e.message}")
+        raise
+      rescue StandardError => e
+        handle_unexpected_error(e)
+        raise
+      end
+    end
+  end
+end

data/lib/parabot/commands/start.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Commands
+    class Start < Base
+      desc "Start Claude in a new tmux pane"
+
+      def call(**)
+        init(**)
+        dry_run_log "Would start Claude session using messaging adapter: #{config.messaging_adapter}"
+
+        start_claude_session
+      rescue TmuxError => e
+        handle_tmux_error(e)
+      rescue StandardError => e
+        handle_unexpected_error(e)
+      end
+
+      private
+
+      def start_claude_session
+        messaging_adapter.start_session()
+      end
+
+      def handle_tmux_error(error)
+        logger.error("Failed to start Claude session: #{error.message}")
+      end
+
+      def handle_unexpected_error(error)
+        logger.error("Unexpected error: #{error.message}")
+        logger.debug(error.backtrace.join("\n")) if options[:verbose]
+      end
+    end
+  end
+end

data/lib/parabot/commands/test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Commands
+    class Test < Base
+      desc "Run tests and send results to Claude"
+
+      argument :files, type: :array, required: false, desc: "Test files or arguments to pass to test command"
+
+      def call(files: [], **options)
+        init(**options)
+
+        test_args = files || []
+        dry_run_log("Would run tests with args: #{test_args.join(' ')}")
+
+        test_results = execute_tests(test_args)
+        message = build_message(test_results)
+        send_message(message)
+
+      rescue TestExecutionError => e
+        logger.error("Test execution failed: #{e.message}")
+        raise
+      rescue StandardError => e
+        handle_unexpected_error(e)
+        raise
+      end
+
+      private
+
+      def execute_tests(test_args)
+        logger.info("Running tests with command detection...")
+
+        test_runner.run_tests(args: test_args).tap do |test_results|
+          raise TestExecutionError unless test_results
+        end
+      end
+
+      def build_message(test_results)
+        config.test_analysis_prompt.gsub("{{results}}", test_results.output)
+      end
+    end
+  end
+end

data/lib/parabot/commands/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Commands
+    class Version < Base
+      desc "Show version information"
+
+      def call(**)
+        puts "Parabot Ruby CLI v#{Parabot::VERSION}"
+        puts "A modern Ruby implementation of the Parabot TDD assistant"
+        puts
+        puts "Ruby version: #{RUBY_VERSION}"
+        puts "Platform: #{RUBY_PLATFORM}"
+      end
+    end
+  end
+end

data/lib/parabot/commands.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "commands/base"
+require_relative "commands/init"
+require_relative "commands/start"
+require_relative "commands/test"
+require_relative "commands/message"
+require_relative "commands/custom_commands"
+require_relative "commands/version"
+require_relative "commands/doctor"
+
+module Parabot
+  module Commands
+  end
+end

data/lib/parabot/configuration.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "config"
+require "pathname"
+require "yaml"
+
+require_relative "errors"
+require_relative "language_detector"
+require_relative "system"
+
+module Parabot
+  class Configuration
+    class << self
+      def load(file = nil, project_root = nil)
+        @instance ||= new(project_root).tap { |config| config.load_config(file) }
+      end
+
+      def current
+        @instance || load
+      end
+
+      def reset!
+        @instance = nil
+      end
+    end
+
+    attr_reader :config, :project_root
+
+    def initialize(project_root = nil)
+      @project_root = project_root || Dir.pwd
+      setup_config
+    end
+
+    def load_config(file = nil)
+      files = file ? resolve_config_file_path(file)
+                   : config_files
+
+      Config.load_and_set_settings(*files)
+
+      @config = Settings
+    rescue StandardError => e
+      raise ConfigurationError, "Failed to load configuration: #{e.message}"
+    end
+
+    # Configuration accessors
+    def log_level
+      config.log_level&.to_sym || :warn
+    end
+
+    def log_file
+      config.log_file || "stderr"
+    end
+
+    def test_command(language)
+      # Get test command from language-specific configuration
+      lang_config = config.languages&.public_send(language.to_sym)
+      lang_config&.test_command
+    end
+
+    def custom_commands
+      config.commands&.to_h || {}
+    end
+
+    def language
+      config.language || "auto"
+    end
+
+    def all_language_extensions
+      return {} unless config.languages
+
+      @all_language_extensions ||=
+        config.languages.map do |lang, lang_config|
+          extensions = lang_config&.file_extensions&.to_a || []
+          [lang, extensions] unless extensions.empty?
+        end.compact.to_h
+    end
+
+    def all_language_project_files
+      return {} unless config.languages
+
+      result = {}
+      config.languages.each do |lang, lang_config|
+        project_files = lang_config&.project_files&.to_a || []
+        result[lang] = project_files unless project_files.empty?
+      end
+      result
+    rescue StandardError
+      {}
+    end
+
+    # Always returns: base_prompt + language_specific_addition
+    def system_prompt(detected_languages = [])
+      base_prompt = config.system_prompt || ""
+      languages = Array(detected_languages)
+
+      language_addition =
+        languages.map do |lang|
+          language_specific_system_prompt(lang)
+        end.reject(&:empty?).join("\n")
+
+      base_prompt + maybe_multi_language_notice(languages) + language_addition
+    end
+
+    def test_analysis_prompt
+      test_guidance = config.test_guidance
+
+      template = <<~TEMPLATE
+        Analyze TEST RESULTS:
+        <test_results_file>
+        {{results}}
+        </test_results_file>
+
+        #{test_guidance}
+      TEMPLATE
+
+      template.strip
+    end
+
+    def test_guidance(language)
+      config.languages&.public_send(language.to_s)&.test_guidance
+    end
+
+    def messaging_adapter
+      config.adapter&.to_sym || :tmux
+    end
+
+    private
+
+    def resolve_config_file_path(file)
+      Parabot::System.determine_path(file, project_root).tap do |resolved_file|
+        logger.warn("file #{resolved_file} not found") unless File.exist?(resolved_file)
+      end
+    end
+
+    def setup_config
+      Config.setup do |config|
+        config.const_name = "Settings"
+        config.use_env = true
+        config.env_prefix = "PARABOT"
+        config.env_separator = "_"
+      end
+    end
+
+    def config_files
+      [
+        Pathname.new(Dir.home) / ".parabot.yml",
+        Pathname.new(Dir.home) / ".config" / "parabot" / ".parabot.yml",
+        Parabot::System.determine_system_path(".parabot.yml", project_root)
+      ].map do |path|
+        path.to_s if File.exist?(path)
+      end.compact
+    end
+
+    def resolve_log_file_path
+      path = Pathname.new(log_file)
+      return path.to_s if path.absolute?
+
+      (Pathname.new(project_root) / path).to_s
+    end
+
+    def ensure_log_directory(file_path)
+      dir = File.dirname(file_path)
+      return if Dir.exist?(dir)
+
+      require "fileutils"
+      FileUtils.mkdir_p(dir)
+    rescue SystemCallError => e
+      raise ConfigurationError, "Cannot create log directory #{dir}: #{e.message}"
+    end
+
+    def logger
+      require "semantic_logger"
+      SemanticLogger[self.class.name]
+    end
+
+    # Multi-language prompt support methods
+    def language_specific_system_prompt(language)
+      return "" unless language.is_a?(Symbol)
+
+      lang_config = config.languages&.public_send(language.to_s)
+      return "" unless lang_config&.system_prompt
+
+      "\n\n#{lang_config.system_prompt}"
+    end
+
+    def language_specific_test_guidance(language)
+      return "" unless language.is_a?(Symbol)
+
+      lang_config = config.languages&.public_send(language.to_s)
+      lang_config&.test_guidance || ""
+    end
+
+    def maybe_multi_language_notice(languages)
+      return "" if Array(languages).size < 2
+
+      "\n\nMULTI-LANGUAGE PROJECT: #{languages.join(', ')}\nApply appropriate language conventions for each.\n"
+    end
+  end
+end

data/lib/parabot/dry_run_logging.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Parabot
+  # Module for dry run logging functionality
+  # Provides a clean interface for logging dry run operations
+  module DryRunLogging
+    private
+
+    def dry_run_log(message)
+      return logger.debug(message) unless dry_run?
+
+      message ||= "nil"
+
+      # for every line in  the message, adds "DRY RUN: " prefix
+      puts message.split("\n").map { |line| "DRY RUN: #{line}" }.join("\n")
+    end
+
+    def dry_run?
+      !!@dry_run
+    end
+  end
+end

data/lib/parabot/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Parabot
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+  class TmuxError < Error; end
+  class TestExecutionError < Error; end
+  class LanguageDetectionError < Error; end
+  class CommandError < Error; end
+  class ValidationError < Error; end
+end

data/lib/parabot/language_detector.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "set"
+require "shellwords"
+require "yaml"
+
+module Parabot
+  class LanguageDetector
+    def initialize(config = Configuration.current)
+      @config = config
+      @project_root = config.project_root
+    end
+
+    # Class method for detecting languages with all available language configs loaded
+    # Used by init command and other contexts that need complete language detection
+    def self.detect_with_all_languages(project_root = Dir.pwd)
+      config = create_full_language_config(project_root)
+      detector = new(config)
+      detector.detect_all_languages(project_root)
+    end
+
+    private_class_method def self.create_full_language_config(project_root)
+      # Load all available language configs
+      config_dir = File.join(__dir__, "../../config")
+      languages = {}
+
+      Dir.glob(File.join(config_dir, "languages/*.yml")).each do |lang_file|
+        lang_name = File.basename(lang_file, ".yml")
+        languages[lang_name] = YAML.load_file(lang_file)
+      end
+
+      # Create a minimal config object that supports language detection
+      Class.new do
+        def initialize(languages, project_root)
+          @languages = languages
+          @project_root = project_root
+        end
+
+        attr_reader :project_root
+
+        def all_language_extensions
+          @languages.transform_values { |lang_config| lang_config["file_extensions"] }
+        end
+
+        def all_language_project_files
+          result = {}
+          @languages.each do |lang, lang_config|
+            project_files = lang_config["project_files"] || []
+            result[lang] = project_files unless project_files.empty?
+          end
+          result
+        end
+
+        def detect_language_from_extensions(extensions)
+          all_language_extensions.each do |lang, lang_extensions|
+            next if lang_extensions.nil?
+            return lang if (lang_extensions & extensions).any?
+          end
+          nil
+        end
+      end.new(languages, project_root)
+    end
+
+    def detect_all_languages(path = project_root)
+      detected_languages = Set.new
+
+      # 1. Check for definitive project files first (always included)
+      detected_languages.merge(detect_from_project_files(path))
+
+      # 2. Get extensions with counts, filter by threshold to avoid fixture noise
+      detected_languages.merge(detect_from_extensions_with_threshold(path))
+
+      # 3. Return sorted array or [:unknown] if empty
+      detected_languages.empty? ? [:unknown] : detected_languages.to_a.sort
+    end
+
+    # Find language from file extensions
+    def find_language_from_extensions(extensions)
+      return nil if extensions.empty?
+
+      config.all_language_extensions.each do |lang, lang_extensions|
+        next if lang_extensions.empty?
+        return lang.to_s if (lang_extensions & extensions).any?
+      end
+
+      nil
+    end
+
+    private
+
+    attr_reader :config, :project_root
+
+    def detect_from_project_files(path)
+      return [] unless config.all_language_project_files
+      return [] unless File.directory?(path.to_s)
+
+      escaped_path = Shellwords.escape(path.to_s)
+      all_files = `git -C #{escaped_path} ls-files --cached --others --exclude-standard 2>/dev/null`.split("\n")
+
+      detected = []
+      config.all_language_project_files.each do |lang, project_files|
+        project_files.each do |project_file|
+          if all_files.include?(project_file)
+            detected << lang.to_sym
+            break # Found this language, move to next
+          end
+        end
+      end
+
+      detected
+    rescue StandardError
+      []
+    end
+
+    def detect_from_extensions_with_threshold(path)
+      extension_counts = get_extension_counts(path)
+      return [] if extension_counts.empty?
+
+      # Only extensions with 2+ files (duplicates) indicate significant codebases
+      # This automatically filters out single fixture files
+      significant_extensions = extension_counts.keys
+
+      # Map extensions to languages using our own method
+      significant_extensions.filter_map do |ext|
+        lang = find_language_from_extensions([ext])
+        lang&.to_sym
+      end
+
+    rescue StandardError
+      []
+    end
+
+    def get_extension_counts(path)
+      return {} unless File.directory?(path.to_s)
+
+      escaped_path = Shellwords.escape(path.to_s)
+      # Get extensions with 2+ occurrences (avoid single fixture files)
+      output = `git -C #{escaped_path} ls-files --cached --others --exclude-standard | rev | cut -d . -f1 | rev | sort | uniq -cd | sort -gr | head -10 2>/dev/null`
+
+      # Parse "count extension" format from uniq -cd output
+      counts = {}
+      output.split("\n").each do |line|
+        parts = line.strip.split
+        next unless parts.size == 2
+
+        count, ext = parts[0].to_i, parts[1]
+        next if ext.empty? || count <= 0
+
+        counts[".#{ext}"] = count
+      end
+
+      counts
+    rescue StandardError
+      {}
+    end
+  end
+end