parabot 1.0.0

data/lib/parabot/language_inference.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Parabot
+  class LanguageInference
+    EXTENSION_PATTERNS = {
+      "python" => [".py", ".pyx", ".pyi"],
+      "java" => [".java"],
+      "cpp" => [".cpp", ".cc", ".cxx", ".c++", ".hpp", ".h"],
+      "c" => [".c", ".h"],
+      "go" => [".go"],
+      "rust" => [".rs"],
+      "php" => [".php"],
+      "swift" => [".swift"],
+      "dart" => [".dart"],
+      "scala" => [".scala"],
+      "clojure" => [".clj", ".cljs", ".cljc"],
+      "haskell" => [".hs", ".lhs"],
+      "erlang" => [".erl", ".hrl"],
+      "csharp" => [".cs"],
+      "fsharp" => [".fs", ".fsx"],
+      "perl" => [".pl", ".pm"],
+      "lua" => [".lua"],
+      "r" => [".R", ".r"],
+      "matlab" => [".m"],
+      "julia" => [".jl"]
+    }.freeze
+
+    TEST_DIR_PATTERNS = {
+      "python" => %w[tests test],
+      "java" => ["src/test/java", "test"],
+      "go" => ["."], # Go tests alongside source
+      "rust" => ["tests"],
+      "php" => %w[tests test],
+      "swift" => ["Tests"],
+      "dart" => ["test"],
+      "scala" => ["src/test/scala", "test"],
+      "clojure" => ["test"],
+      "haskell" => ["test"],
+      "erlang" => ["test"],
+      "csharp" => %w[test tests],
+      "fsharp" => %w[test tests],
+      "perl" => %w[t test],
+      "lua" => %w[test spec],
+      "r" => %w[tests test],
+      "matlab" => ["test"],
+      "julia" => ["test"]
+    }.freeze
+
+    PROJECT_FILES = {
+      "python" => ["requirements.txt", "setup.py", "pyproject.toml", "Pipfile"],
+      "java" => ["pom.xml", "build.gradle", "build.gradle.kts"],
+      "go" => ["go.mod", "go.sum"],
+      "rust" => ["Cargo.toml", "Cargo.lock"],
+      "php" => ["composer.json", "composer.lock"],
+      "swift" => ["Package.swift"],
+      "dart" => ["pubspec.yaml"],
+      "scala" => ["build.sbt", "project/build.properties"],
+      "clojure" => ["project.clj", "deps.edn"],
+      "haskell" => ["*.cabal", "stack.yaml"],
+      "erlang" => ["rebar.config", "erlang.mk"],
+      "csharp" => ["*.csproj", "*.sln"],
+      "fsharp" => ["*.fsproj", "*.sln"],
+      "perl" => ["Makefile.PL", "Build.PL"],
+      "lua" => ["*.rockspec"],
+      "r" => %w[DESCRIPTION NAMESPACE],
+      "matlab" => ["*.prj"],
+      "julia" => ["Project.toml", "Manifest.toml"]
+    }.freeze
+
+    def self.infer_extensions(language)
+      EXTENSION_PATTERNS[language.downcase] || [".#{language}"]
+    end
+
+    def self.infer_test_dirs(language)
+      TEST_DIR_PATTERNS[language.downcase] || %w[test tests]
+    end
+
+    def self.infer_project_files(language)
+      PROJECT_FILES[language.downcase] || []
+    end
+  end
+end

data/lib/parabot/logging_setup.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "semantic_logger"
+require "pathname"
+
+module Parabot
+  class LoggingSetup
+    def self.setup_with_config(config)
+      new(config.log_level, config.log_file, config.method(:resolve_log_file_path),
+          config.method(:ensure_log_directory)).setup
+    end
+
+    def self.setup_default(level = :info, file = "stderr")
+      new(level, file).setup
+    end
+
+    def initialize(level = :info, file = "stderr", file_resolver = nil, dir_ensurer = nil)
+      @level = level
+      @file = file
+      @file_resolver = file_resolver
+      @dir_ensurer = dir_ensurer
+    end
+
+    def setup
+      SemanticLogger.default_level = @level
+      SemanticLogger.clear_appenders!
+
+      if %w[stderr stdout].include?(@file)
+        setup_stderr_logging
+      else
+        setup_file_logging
+      end
+    rescue StandardError => e
+      # Fall back to stderr logging if file logging fails
+      fallback_to_stderr(e)
+    end
+
+    private
+
+    attr_reader :level, :file, :file_resolver, :dir_ensurer
+
+    def setup_stderr_logging
+      SemanticLogger.add_appender(io: $stderr, formatter: custom_formatter)
+    end
+
+    def setup_file_logging
+      file_path = file_resolver ? file_resolver.call : @file
+      dir_ensurer&.call(file_path)
+      SemanticLogger.add_appender(file: file_path, formatter: :default)
+    end
+
+    def fallback_to_stderr(error)
+      SemanticLogger.clear_appenders!
+      SemanticLogger.add_appender(io: $stderr, formatter: custom_formatter)
+      SemanticLogger["Parabot::LoggingSetup"].warn("Failed to setup file logging: #{error.message}")
+    end
+
+    def custom_formatter
+      proc do |log|
+        reset_color = "\e[0m"
+        level_color = case log.level
+                      when :trace, :debug then "\e[0;90m"   # GRAY - Dark gray like shell
+                      when :info then "\e[0;36m"            # CYAN - Cyan like shell
+                      when :warn then "\e[1;33m"            # YELLOW - Bold yellow like shell
+                      when :error, :fatal then "\e[0;31m"   # RED - Red like shell
+                      else "\e[0m" # Default
+                      end
+        level_tag = "[#{log.level.to_s.upcase}]"
+        "#{level_color}#{level_tag}#{reset_color} #{log.message}"
+      end
+    end
+  end
+end

data/lib/parabot/messaging/adapter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Messaging
+    # Base class for messaging adapters that can send messages to Claude
+    # in different ways (tmux, direct API calls, etc.)
+    class Adapter
+      # @abstract
+      # @param message [String] the message to send to Claude
+      # @return [Boolean] true if message was sent successfully
+      # @raise [NotImplementedError] if not implemented by subclass
+      def send_message(message)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # @abstract
+      # @param system_prompt [String, nil] optional system prompt
+      # @return [Boolean] true if Claude session was started successfully
+      # @raise [NotImplementedError] if not implemented by subclass
+      def start_session(system_prompt: nil)
+        raise NotImplementedError, "#{self.class} must implement #start_session"
+      end
+
+      # @abstract
+      # @return [Boolean] true if session was ended successfully
+      # @raise [NotImplementedError] if not implemented by subclass
+      def end_session
+        raise NotImplementedError, "#{self.class} must implement #end_session"
+      end
+
+      # @abstract
+      # @return [Boolean] true if abort command was sent successfully (usually ESC key)
+      # @raise [NotImplementedError] if not implemented by subclass
+      def abort
+        raise NotImplementedError, "#{self.class} must implement #abort"
+      end
+
+      # @abstract
+      # @return [Boolean] true if Claude session is available and active
+      # @raise [NotImplementedError] if not implemented by subclass
+      def session_active?
+        raise NotImplementedError, "#{self.class} must implement #session_active?"
+      end
+
+      private
+
+      def logger
+        require "semantic_logger"
+        SemanticLogger[self.class.name]
+      end
+    end
+  end
+end

data/lib/parabot/messaging/adapter_factory.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "tmux_adapter"
+require_relative "dry_run_adapter"
+
+module Parabot
+  module Messaging
+    # Factory class to create appropriate messaging adapters
+    class AdapterFactory
+      # Available adapter types
+      ADAPTERS = {
+        tmux: TmuxAdapter,
+        dry_run: DryRunAdapter
+      }.freeze
+
+      # @param type [Symbol] the type of adapter to create (:tmux, :dry_run)
+      # @param kwargs [Hash] additional keyword arguments to pass to the adapter constructor
+      # @return [Messaging::Adapter] an instance of the requested adapter
+      # @raise [ArgumentError] if adapter type is not supported
+      def self.create(type = :tmux, **kwargs)
+        adapter_class = ADAPTERS[type]
+        raise ArgumentError, "Unsupported adapter type: #{type}. Available types: #{ADAPTERS.keys}" unless adapter_class
+
+        adapter_class.new(**kwargs)
+      end
+
+      # @return [Array<Symbol>] list of available adapter types
+      def self.available_types
+        ADAPTERS.keys
+      end
+    end
+  end
+end

data/lib/parabot/messaging/dry_run_adapter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+require_relative "../dry_run_logging"
+
+module Parabot
+  module Messaging
+    # Dry-run implementation of the MessagingAdapter that logs actions without executing them
+    class DryRunAdapter < Adapter
+      include DryRunLogging
+
+      def initialize(dry_run: true, **_kwargs)
+        @dry_run = dry_run
+      end
+
+      # @param message [String] the message to send to Claude
+      # @return [Boolean] always true (simulated success)
+      def send_message(message)
+        dry_run_log "Would send message to Claude:"
+        puts message
+        true
+      end
+
+      # @param system_prompt [String, nil] optional system prompt
+      # @return [Boolean] always true (simulated success)
+      def start_session(system_prompt: nil)
+        dry_run_log "Would start Claude session"
+        if system_prompt
+          dry_run_log "Would use system prompt: #{system_prompt[0..100]}#{'...' if system_prompt.length > 100}"
+        else
+          dry_run_log "Would start without system prompt"
+        end
+        true
+      end
+
+      # @return [Boolean] always true (simulated success)
+      def end_session
+        dry_run_log "Would end Claude session"
+        true
+      end
+
+      # @return [Boolean] always true (simulated success)
+      def abort
+        dry_run_log "Would send abort command (ESC key) to Claude"
+        true
+      end
+
+      # @return [Boolean] always true (simulated active session)
+      def session_active?
+        dry_run_log "Would check if Claude session is active"
+        true
+      end
+    end
+  end
+end

data/lib/parabot/messaging/tmux_adapter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+require_relative "../tmux_manager"
+
+module Parabot
+  module Messaging
+    # Tmux implementation of the MessagingAdapter
+    class TmuxAdapter < Adapter
+      attr_reader :tmux_manager
+
+      def initialize(dry_run: false, **_kwargs)
+        @tmux_manager = TmuxManager.new(dry_run: dry_run)
+      end
+
+      # @param message [String] the message to send to Claude
+      # @return [Boolean] true if message was sent successfully
+      def send_message(message)
+        tmux_manager.send_to_claude(message)
+      end
+
+      # @param system_prompt [String, nil] optional system prompt
+      # @return [Boolean] true if Claude session was started successfully
+      def start_session(system_prompt: nil)
+        tmux_manager.start_claude_session(system_prompt: system_prompt)
+      end
+
+      # @return [Boolean] true if session was ended successfully
+      def end_session
+        session = tmux_manager.find_claude_session
+        return false unless session
+
+        target = tmux_manager.find_claude_target(session)
+
+        # Send Ctrl+C then exit command
+        send_cmd("tmux send-keys -t #{session}:#{target.tr(':', '.')} C-c")
+        sleep(0.2)
+        send_cmd("tmux send-keys -t #{session}:#{target.tr(':', '.')} exit Enter")
+
+        true
+      rescue TmuxError
+        false
+      end
+
+      # @return [Boolean] true if abort command was sent successfully (ESC key)
+      def abort
+        session = tmux_manager.find_claude_session
+        return false unless session
+
+        target = tmux_manager.find_claude_target(session)
+
+        # Send ESC key to abort current Claude response
+        send_cmd("tmux send-keys -t #{session}:#{target.tr(':', '.')} Escape")
+
+        true
+      rescue TmuxError
+        false
+      end
+
+      # @return [Boolean] true if Claude session is available and active
+      def session_active?
+        session = tmux_manager.find_claude_session
+        return false unless session
+
+        target = tmux_manager.find_claude_target(session)
+
+        # Check if the target pane has a Claude process running
+        window_pane = target.tr(":", ".")
+        result = tmux_manager.run_command("tmux list-panes -t #{session}:#{window_pane} -F '\#{pane_current_command}'")
+        result.success? && result.out.strip.match?(/claude/i)
+      rescue SystemCallError
+        false
+      end
+
+      private
+
+      def send_cmd(command)
+        tmux_manager.run_command(command)
+      end
+    end
+  end
+end

data/lib/parabot/system.rb

@@ -0,0 +1,41 @@
+require "semantic_logger"
+
+module Parabot
+  class System
+    PARABOT_DIR = ".parabot".freeze
+
+    class << self
+      def logger
+        SemanticLogger["Parabot"]
+      end
+
+      def determine_path(filename, project_root)
+        return filename if Pathname.new(filename).absolute?
+
+        File.join(project_root, filename)
+      end
+
+      def determine_system_path(filename, project_root)
+        ensure_parabot_directory_in(project_root)
+        File.join(project_root, PARABOT_DIR, filename)
+      end
+
+      def determine_config_path(relative_path)
+        File.join(__dir__, "../../config", relative_path)
+      end
+
+      private
+
+      def ensure_parabot_directory_in(project_root)
+        path = File.join(project_root, PARABOT_DIR)
+
+        unless Dir.exist?(path)
+          FileUtils.mkdir_p(path)
+          logger.info("Created parabot directory: #{path}")
+        end
+      rescue SystemCallError => e
+        logger.warn("Cannot create parabot directory #{path}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/parabot/test_runner.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "open3"
+require "ostruct"
+require "fileutils"
+require "shellwords"
+require "tempfile"
+require_relative "configuration"
+require_relative "dry_run_logging"
+require_relative "system"
+
+module Parabot
+  class TestRunner
+    include DryRunLogging
+
+    TestExecutionError = Class.new(StandardError)
+    TestResult = Struct.new(:exit_status, :output) do
+      def success?
+        exit_status.zero?
+      end
+    end
+
+    def initialize(messaging_adapter, language_detector, dry_run: false, config: nil, language: nil)
+      @config = config || Configuration.current
+      @dry_run = dry_run
+      @messaging_adapter = messaging_adapter
+      @language = Array(language).first
+      @language_detector = language_detector
+    end
+
+    def run_tests(args: [], send_to_claude: true)
+      test_command = determine_test_command_from_context(args)
+
+      logger.info("Running tests...")
+      logger.info("Executing: #{test_command}")
+
+      result = run_command(test_command)
+      test_results = format_test_results(test_command, result)
+      output_file = save_test_output(test_results)
+
+      TestResult.new(
+        exit_status: result.exit_status,
+        output: output_file || test_results
+      )
+    rescue SystemCallError => e
+      logger.error("Test execution failed: #{e.message}")
+      false
+    rescue StandardError => e
+      raise TestExecutionError, "Failed to run tests: #{e.message}"
+    end
+
+    private
+
+    attr_reader :config, :messaging_adapter, :language, :language_detector
+
+    def run_command(command)
+      dry_run_log(command)
+      return dry_run_stub if dry_run?
+
+      execute_test_command(command)
+    end
+
+    def determine_test_command_from_context(args)
+      detected_language = language || detect_language_from_context(args)
+
+      dry_run_log("Detected language: #{detected_language}")
+      build_command(detected_language, args)
+    end
+
+    def detect_language_from_context(args)
+      detect_from_file_extensions(args) \
+        || detect_from_directory_scanning(args) \
+        || language_detector.detect_all_languages.first
+    end
+
+    def detect_from_file_extensions(args)
+      extensions = args.flat_map { |arg| extract_extensions_from_path(arg) }.compact.uniq
+      language_detector.find_language_from_extensions(extensions)
+    end
+
+    def detect_from_directory_scanning(args)
+      directories = Array(args.select { |arg| File.directory?(arg) })
+
+      directories.each do |dir|
+        languages = language_detector.detect_all_languages(dir)
+        return languages.first unless languages.empty?
+      end
+
+      nil
+    end
+
+    def extract_extensions_from_path(path)
+      # Use System.determine_path to handle both absolute and relative paths
+      full_path = System.determine_path(path, config.project_root)
+      
+      if File.exist?(full_path)
+        [File.extname(full_path)]
+      elsif path.include?("*") || path.include?("?")
+        # Handle glob patterns - use full_path for the glob too
+        Dir.glob(full_path).map { |f| File.extname(f) }.uniq
+      else
+        []
+      end.reject(&:empty?)
+    end
+
+    def build_command(language, args)
+      base_command = config.test_command(language)
+      args.any? ? "#{base_command} #{args.join(' ')}"
+                : base_command
+    end
+
+    def execute_test_command(command)
+      temp_file = Tempfile.new("parabot_test")
+
+      begin
+        script_command = "script -q -c #{command.shellescape} /dev/null 2>&1 | tee #{temp_file.path.shellescape}"
+
+        # Execute the streaming command
+        system(script_command)
+        exit_status = $?.exitstatus
+
+        # Read the captured output
+        temp_file.rewind
+        output = temp_file.read
+
+        TestResult.new(
+          exit_status: exit_status,
+          output: output
+        )
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    rescue SystemCallError => e
+      logger.error("Failed to execute test command: #{e.message}")
+
+      TestResult.new(
+        exit_status: 1,
+        output: "Error executing test: #{e.message}"
+      )
+    end
+
+    def format_test_results(command, result)
+      status = result.success? ? "passed" : "failed"
+
+      <<~RESULTS
+        Command: #{command}
+        Status: #{status}
+        Exit code: #{result.exit_status}
+
+        Output:
+        #{result.output}
+      RESULTS
+    end
+
+    def save_test_output(results_text)
+      output_file = Parabot::System.determine_system_path("tests_output", config.project_root)
+
+      File.write(output_file, results_text)
+      logger.info("Test results saved to #{output_file}")
+
+      output_file
+    rescue SystemCallError => e
+      logger.warn("Failed to save test output to file: #{e.message}")
+      nil
+    end
+
+    def dry_run_stub
+      TestResult.new(
+        exit_status: 0,
+        output: "DRY RUN: Mock test output\n\n3 examples, 0 failures\n\nFinished in 0.123 seconds"
+      )
+    end
+
+    def logger
+      Parabot::System.logger
+    end
+  end
+end