parabot 1.0.0

data/lib/parabot/tmux_manager.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "open3"
+require "ostruct"
+require "shellwords"
+require_relative "dry_run_logging"
+
+module Parabot
+  class TmuxManager
+    include DryRunLogging
+
+    def initialize(dry_run: false)
+      @dry_run = dry_run
+    end
+
+    def find_claude_session
+      # First try to find by name pattern
+      sessions = list_sessions
+      claude_session = sessions.find { |session| session.match?(/claude/i) }
+      return claude_session if claude_session
+
+      # Then check for Claude processes in any session
+      sessions.each do |session|
+        panes = list_panes(session)
+        claude_pane = panes.find { |pane| pane[:command].match?(/claude/i) }
+        return session if claude_pane
+      end
+
+      nil
+    rescue SystemCallError
+      nil
+    end
+
+    def find_claude_target(session)
+      # First check current window for Claude
+      current_window = current_window_index(session)
+      claude_pane = find_claude_pane_in_window(session, current_window)
+      return "#{current_window}:#{claude_pane}" if claude_pane
+
+      # Check for window named claude
+      windows = list_windows(session)
+      claude_window = windows.find { |w| w[:name].match?(/claude/i) }
+
+      if claude_window
+        claude_pane = find_claude_pane_in_window(session, claude_window[:index])
+        return "#{claude_window[:index]}:#{claude_pane || 0}"
+      end
+
+      # Check all windows for Claude process
+      windows.each do |window|
+        next if window[:index] == current_window
+
+        claude_pane = find_claude_pane_in_window(session, window[:index])
+        return "#{window[:index]}:#{claude_pane}" if claude_pane
+      end
+
+      # Default to current window, first pane
+      "#{current_window}:0"
+    rescue SystemCallError
+      "0:0"
+    end
+
+    def send_to_claude(message)
+      session = find_claude_session
+      raise TmuxError, "No tmux session with Claude found" unless session
+
+      target = find_claude_target(session)
+      logger.info("Found Claude in session '#{session}', target '#{target}'")
+
+      # Send the message
+      logger.info("Sending message to Claude...")
+      send_keys(session, target, "Escape")
+      wait_for_claude(0.1)
+      send_keys(session, target, message)
+      wait_for_claude(0.2)
+      send_keys(session, target, "Enter")
+      wait_for_claude(0.1)
+      send_keys(session, target, "Enter")
+
+      logger.info("Message sent successfully")
+      true
+    rescue SystemCallError => e
+      raise TmuxError, "Failed to send message to Claude: #{e.message}"
+    end
+
+    def start_claude_session(system_prompt: nil)
+      current_session = current_session_name
+      raise TmuxError, "Not in a tmux session. Please run this command from within tmux." unless current_session
+
+      logger.info("Creating vertical pane (30% width)...")
+
+      # Create vertical pane on the left (30% of screen)
+      result = run_command("tmux split-window -h -l 30% -c '#{Dir.pwd}' -b")
+      raise TmuxError, "Failed to create tmux pane" unless result.success?
+
+      # Get the newly created pane
+      new_pane = run_command('tmux display-message -p \'#{pane_index}\'').out.strip
+
+      # Rename the pane for easier identification
+      run_command("tmux select-pane -t #{new_pane} -T claude")
+
+      # Start claude with system prompt if provided
+      claude_command = if system_prompt
+                         escaped_prompt = system_prompt.shellescape
+                         "claude --system-prompt #{escaped_prompt}"
+                       else
+                         "claude"
+                       end
+
+      # Send keys to start claude (let tmux use current context like shell version)
+      run_command("tmux send-keys -t #{new_pane} #{claude_command.shellescape} Enter")
+
+      # Switch back to original pane
+      run_command("tmux select-pane -R")
+
+      logger.info("Claude session started in pane #{new_pane}")
+      logger.info("Use 'Ctrl-B + arrow keys' to navigate between panes")
+      true
+    rescue SystemCallError => e
+      raise TmuxError, "Failed to start Claude session: #{e.message}"
+    end
+
+    def list_sessions
+      result = run_command("tmux list-sessions")
+      return [] unless result.success?
+
+      result.out.lines.map do |line|
+        line.split(":").first.strip
+      end
+    rescue SystemCallError
+      []
+    end
+
+    private
+
+    def dry_run?
+      !!@dry_run
+    end
+
+    def current_session_name
+      result = run_command('tmux display-message -p \'#{session_name}\'')
+      result.success? ? result.out.strip : nil
+    rescue SystemCallError
+      nil
+    end
+
+    def current_window_index(session)
+      command = "tmux display-message -t " + session + ' -p \'#{window_index}\''
+      result = run_command(command)
+      result.success? ? result.out.strip : "0"
+    rescue SystemCallError
+      "0"
+    end
+
+    def list_panes(session)
+      command = "tmux list-panes -t " + session + ' -F \'#{pane_index}:#{pane_current_command}\''
+      result = run_command(command)
+      return [] unless result.success?
+
+      result.out.lines.map do |line|
+        index, command = line.strip.split(":", 2)
+        { index: index, command: command }
+      end
+    rescue SystemCallError
+      []
+    end
+
+    def list_windows(session)
+      command = "tmux list-windows -t " + session + ' -F \'#{window_index}:#{window_name}\''
+      result = run_command(command)
+      return [] unless result.success?
+
+      result.out.lines.map do |line|
+        index, name = line.strip.split(":", 2)
+        { index: index, name: name }
+      end
+    rescue SystemCallError
+      []
+    end
+
+    def find_claude_pane_in_window(session, window)
+      command = "tmux list-panes -t " + session + ":" + window + ' -F \'#{pane_index}:#{pane_current_command}\''
+      panes = run_command(command)
+      return nil unless panes.success?
+
+      claude_pane = panes.out.lines.find { |line| line.match?(/claude/i) }
+      claude_pane&.split(":")&.first
+    rescue SystemCallError
+      nil
+    end
+
+    def send_keys(session, target, keys)
+      # Convert window:pane format to window.pane format for tmux
+      target_formatted = target.include?(":") ? target.tr(":", ".") : target
+      run_command("tmux send-keys -t #{session}:#{target_formatted} #{keys.shellescape}")
+    end
+
+    def wait_for_claude(seconds)
+      sleep(seconds) unless dry_run?
+    end
+
+    def run_command(command)
+      if dry_run?
+        dry_run_log(command)
+        # Return realistic mock output based on command type
+        mock_output = case command
+                      when /list-sessions/
+                        "main: 1 windows (created Mon Jan  1 12:00:00 2024)\nclaude: 1 windows (created Mon Jan  1 12:00:00 2024)"
+                      when /display-message.*session_name/
+                        "main"
+                      when /display-message.*pane_index/
+                        "1"
+                      when /display-message.*window_index/
+                        "0"
+                      when /list-panes.*pane_index:pane_current_command/
+                        "0:bash\n1:claude"
+                      when /list-windows/
+                        "0: main* (1 panes) [80x24] [layout active]\n1: claude- (1 panes) [80x24]"
+                      else
+                        ""
+                      end
+
+        OpenStruct.new(
+          out: mock_output,
+          err: "",
+          success?: true,
+          exit_status: 0
+        )
+      else
+        stdout, stderr, status = Open3.capture3(command)
+        OpenStruct.new(
+          out: stdout,
+          err: stderr,
+          success?: status.success?,
+          exit_status: status.exitstatus
+        )
+      end
+    end
+
+    def logger
+      require "semantic_logger"
+      SemanticLogger[self.class.name]
+    end
+  end
+end

data/lib/parabot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Parabot
+  VERSION = "1.0.0"
+end

data/lib/parabot/yaml_text_assembler.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "logger"
+require_relative "system"
+
+module Parabot
+  class YamlTextAssembler
+    def self.assemble_for_languages(detected_languages)
+      supported, unsupported = partition_language_support(detected_languages)
+      warn_about_unsupported_languages(unsupported) if unsupported.any?
+
+      # Convert symbols to strings for consistent processing
+      detected_strings = detected_languages.map(&:to_s)
+
+      # Build YAML as text directly to preserve formatting
+      build_yaml_text(detected_strings, supported, unsupported)
+    end
+
+    def self.supported_languages
+      @supported_languages ||= Dir.glob(System.determine_config_path("languages/*.yml"))
+                                  .map { |file| File.basename(file, ".yml") }
+                                  .sort
+    end
+
+    def self.partition_language_support(languages)
+      string_languages = languages.map(&:to_s)
+      supported = string_languages.select { |lang| supported_languages.include?(lang) }
+      unsupported = string_languages - supported
+      [supported, unsupported]
+    end
+
+    def self.warn_about_unsupported_languages(unsupported)
+      unsupported.each do |lang|
+        logger.warn("#{lang.capitalize} has minimal support - using basic TDD guidance")
+      end
+    end
+
+    def self.logger
+      @logger ||= Logger.new($stderr).tap { |l| l.level = Logger::WARN }
+    end
+
+    def self.read_config_file(path)
+      File.read(System.determine_config_path(path))
+    end
+
+    def self.indent_lines(content, spaces = 2)
+      prefix = " " * spaces
+      content.lines.map { |line| line.empty? ? line : "#{prefix}#{line}" }.join
+    end
+
+    def self.build_yaml_block(key, content, style = "|")
+      "#{key}: #{style}\n" + indent_lines(content).chomp
+    end
+
+    def self.build_yaml_text(_detected_languages, supported, unsupported)
+      sections = []
+
+      # Add YAML document start
+      sections << "---"
+
+      # Add base configuration
+      sections << read_config_file("base.yml")
+      sections << read_config_file("commands.yml")
+      sections << read_config_file("core_prompts/test_guidance.yml")
+      sections << read_config_file("core_prompts/system_prompt.yml")
+
+      # Add languages section
+      sections << build_languages_section(supported, unsupported)
+
+      sections.join("\n\n")
+    end
+
+    def self.build_languages_section(supported, unsupported)
+      result = "languages:"
+
+      supported.each { |lang| result += build_supported_language(lang) }
+      unsupported.each { |lang| result += build_unsupported_language(lang) }
+
+      result
+    end
+
+    def self.build_supported_language(lang)
+      lang_file = System.determine_config_path("languages/#{lang}.yml")
+      return "" unless File.exist?(lang_file)
+
+      lang_content = File.read(lang_file).strip
+      "\n  #{lang}:\n" + indent_lines(lang_content, 4).rstrip
+    end
+
+    def self.build_unsupported_language(lang)
+      result = "\n  #{lang}:"
+      result += build_language_config_arrays(lang)
+      result += build_minimal_prompt_block(lang)
+      result
+    end
+
+    def self.build_language_config_arrays(lang)
+      config = ""
+      config += "\n    file_extensions:"
+      LanguageInference.infer_extensions(lang).each { |ext| config += "\n    - \"#{ext}\"" }
+      config += "\n    test_dir:"
+      LanguageInference.infer_test_dirs(lang).each { |dir| config += "\n    - #{dir}" }
+      config += "\n    project_files:"
+      LanguageInference.infer_project_files(lang).each { |file| config += "\n    - #{file}" }
+      config
+    end
+
+    def self.build_minimal_prompt_block(lang)
+      minimal_prompt = build_minimal_system_prompt(lang)
+      "\n    system_prompt: |-\n" + indent_lines(minimal_prompt, 6).rstrip
+    end
+
+    def self.build_minimal_system_prompt(lang)
+      <<~PROMPT
+        #{lang.upcase} TDD PATTERNS (MINIMAL SUPPORT):
+        - Follow test-first development: write failing test, make it pass, refactor
+        - Use descriptive test names that explain the behavior being tested
+        - Keep tests isolated and independent of each other
+        - Test both success and failure cases
+        - Mock external dependencies to ensure test reliability
+
+        #{lang.upcase} BASIC ANTI-PATTERNS TO AVOID:
+        - NEVER replace specific assertions with generic "does not raise/throw" checks
+        - NEVER convert detailed expectations to simple execution validation
+        - NEVER gut tests by removing behavior validation to make them pass
+        - ALWAYS fix root causes (configuration, mocking, environment) not symptoms
+        - ALWAYS understand what your test assertions are validating before changing them
+
+        DEBUGGING STEPS FOR #{lang.upcase}:
+        - Check project dependencies and build configuration
+        - Verify test framework setup and imports
+        - Use language-specific debugging tools and logging
+        - Ensure proper test isolation and cleanup
+        - Check for missing mocks or test data setup
+
+        ⚠️  MINIMAL LANGUAGE SUPPORT:
+        This is basic TDD guidance for #{lang}. For comprehensive patterns, debugging tips,
+        and language-specific best practices, consider contributing full #{lang} support:
+        https://github.com/AlexParamonov/parabot#contributing-language-support
+
+        Current minimal support includes:
+        - Generic TDD workflow guidance
+        - Basic anti-pattern prevention
+        - Universal debugging approaches
+
+        Missing advanced support:
+        - #{lang}-specific testing frameworks and patterns
+        - Language-specific debugging techniques
+        - Framework-specific best practices
+        - Advanced #{lang} TDD patterns
+      PROMPT
+    end
+  end
+end

data/lib/parabot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "parabot/version"
+require_relative "parabot/errors"
+require_relative "parabot/configuration"
+require_relative "parabot/language_detector"
+require_relative "parabot/tmux_manager"
+require_relative "parabot/test_runner"
+require_relative "parabot/cli"
+
+module Parabot
+  class Error < StandardError; end
+
+  # Main entry point for the CLI
+  def self.start(args = ARGV)
+    CLI.start(args)
+  rescue Parabot::Error => e
+    logger.error(e.message)
+    exit(1)
+  rescue StandardError => e
+    logger.error("Unexpected error: #{e.message}")
+    logger.debug(e.backtrace.join("\n"))
+    exit(1)
+  end
+
+  def self.logger
+    require "semantic_logger"
+    SemanticLogger["Parabot"]
+  end
+end

data/parabot.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "lib/parabot/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "parabot"
+  spec.version = Parabot::VERSION
+  spec.authors = ["Alexander Paramonov"]
+  spec.email = ["alexander.n.paramonov@gmail.com"]
+
+  spec.summary = "AI-powered Test-Driven Development parallel assistant with tmux integration"
+  spec.description = "Parabot is a multi-language TDD assistant that provides intelligent test-driven development support across various programming languages and testing frameworks. Features tmux integration, YAML configuration, and automatic project type detection."
+  spec.homepage = "https://github.com/AlexParamonov/parabot"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables << "parabot"
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "dry-cli", "~> 1.1"
+  spec.add_dependency "config", "~> 5.0"
+  spec.add_dependency "semantic_logger", "~> 4.15"
+
+  # Development dependencies
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.0"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+end

data/scripts/build-distribution

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+#
+# Parabot CLI Distribution Builder
+#
+# Creates a standalone executable for distribution to Linux/Mac systems
+#
+
+# Configuration
+readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+readonly PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+readonly BUILD_DIR="${BUILD_DIR:-$PROJECT_ROOT/build}"
+readonly EXECUTABLE_NAME="parabot"
+readonly SOURCE_EXECUTABLE="$PROJECT_ROOT/exe/parabot"
+
+# Logging functions
+log() { echo "🏗️  $1"; }
+step() { echo "📦 $1"; }
+success() { echo "✅ $1"; }
+error() { echo "❌ $1" >&2; }
+
+# Validation
+validate_prerequisites() {
+    if [[ ! -f "$SOURCE_EXECUTABLE" ]]; then
+        error "Source executable not found: $SOURCE_EXECUTABLE"
+        exit 1
+    fi
+    
+    if [[ ! -x "$SOURCE_EXECUTABLE" ]]; then
+        error "Source executable is not executable: $SOURCE_EXECUTABLE"
+        exit 1
+    fi
+}
+
+# Build process
+build_distribution() {
+    log "Building Parabot CLI Distribution"
+    echo "=================================="
+    
+    validate_prerequisites
+    
+    # Clean build directory
+    step "Cleaning build directory..."
+    rm -rf "$BUILD_DIR"
+    mkdir -p "$BUILD_DIR"
+    
+    # Copy the bundler-isolated executable
+    step "Creating standalone executable..."
+    cp "$SOURCE_EXECUTABLE" "$BUILD_DIR/$EXECUTABLE_NAME"
+    chmod +x "$BUILD_DIR/$EXECUTABLE_NAME"
+}
+
+# Test and report
+test_executable() {
+    local executable="$BUILD_DIR/$EXECUTABLE_NAME"
+    
+    step "Testing the executable..."
+    
+    # Test version command
+    if "$executable" --version >/dev/null 2>&1; then
+        success "Version command works"
+    else
+        error "Version command failed"
+        return 1
+    fi
+    
+    # Test help command (check output rather than exit code)
+    local help_output
+    help_output=$("$executable" --help 2>&1 || true)
+    if echo "$help_output" | grep -q "commands"; then
+        success "Help command works"
+    else
+        error "Help command failed"
+        return 1
+    fi
+}
+
+show_distribution_info() {
+    local file_size
+    file_size=$(du -h "$BUILD_DIR/$EXECUTABLE_NAME" | cut -f1)
+    
+    success "Build complete!"
+    echo ""
+    echo "📊 Distribution Info:"
+    echo "   Executable: $BUILD_DIR/$EXECUTABLE_NAME"
+    echo "   Size: $file_size"
+    echo "   Ruby Version Required: >= 3.0.0"
+    echo ""
+    echo "🚀 Installation Instructions:"
+    echo ""
+    echo "   Local installation:"
+    echo "   sudo cp $BUILD_DIR/$EXECUTABLE_NAME /usr/local/bin/"
+    echo ""
+    echo "   User installation (if ~/bin is in PATH):"
+    echo "   cp $BUILD_DIR/$EXECUTABLE_NAME ~/bin/"
+    echo ""
+    echo "   Direct usage:"
+    echo "   $BUILD_DIR/$EXECUTABLE_NAME --help"
+    echo ""
+}
+
+show_checklist() {
+    echo "🎉 Distribution ready for deployment!"
+    echo ""
+    echo "📋 Distribution checklist:"
+    echo "   □ Test on target Linux system"
+    echo "   □ Test on target macOS system"
+    echo "   □ Verify Ruby 3.0+ requirement"
+    echo "   □ Test all major commands"
+    echo "   □ Document installation process"
+}
+
+# Main execution
+main() {
+    build_distribution
+    test_executable || exit 1
+    show_distribution_info
+    show_checklist
+}
+
+main "$@"