openclacky 0.7.2 → 0.7.4

data/lib/clacky/default_skills/skill-add/scripts/install_from_github.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require 'uri'
+require 'find'
+
+# Install skills from a GitHub repository
+# Usage: ruby install_from_github.rb <github_url>
+class SkillInstaller
+  GITHUB_URL_PATTERNS = [
+    %r{^https?://github\.com/[\w-]+/[\w.-]+(?:\.git)?$},
+    %r{^git@github\.com:[\w-]+/[\w.-]+\.git$}
+  ].freeze
+
+  def initialize(repo_url, target_dir: nil)
+    @repo_url = repo_url
+    @target_dir = target_dir || File.join(Dir.pwd, '.clacky', 'skills')
+    @installed_skills = []
+    @errors = []
+  end
+
+  # Main installation process
+  def install
+    unless valid_github_url?
+      raise ArgumentError, "Invalid GitHub URL: #{@repo_url}"
+    end
+
+    Dir.mktmpdir('clacky-skills-') do |tmpdir|
+      clone_repository(tmpdir)
+      discover_and_install_skills(tmpdir)
+    end
+
+    report_results
+  rescue StandardError => e
+    puts "❌ Installation failed: #{e.message}"
+    exit 1
+  end
+
+  # Validate GitHub URL format
+  private def valid_github_url?
+    GITHUB_URL_PATTERNS.any? { |pattern| @repo_url.match?(pattern) }
+  end
+
+  # Clone the repository to temporary directory
+  private def clone_repository(tmpdir)
+    puts "📦 Cloning repository..."
+    puts "   #{@repo_url}"
+    
+    clone_path = File.join(tmpdir, 'repo')
+    
+    # Use git clone with depth=1 for faster cloning
+    system('git', 'clone', '--depth', '1', @repo_url, clone_path, 
+           out: File::NULL, err: File::NULL)
+    
+    unless $?.success?
+      raise "Failed to clone repository. Please check the URL and your network connection."
+    end
+    
+    @clone_path = clone_path
+  end
+
+  # Discover all skills directories and install them
+  private def discover_and_install_skills(tmpdir)
+    skills_found = false
+    
+    # Search for any directory named 'skills' containing SKILL.md files
+    Find.find(@clone_path) do |path|
+      next unless File.directory?(path)
+      next unless File.basename(path) == 'skills'
+      
+      # Check if this skills directory contains subdirectories with SKILL.md
+      skill_dirs = Dir.glob(File.join(path, '*/SKILL.md')).map { |f| File.dirname(f) }
+      
+      next if skill_dirs.empty?
+      
+      skills_found = true
+      install_skills_from_directory(path, skill_dirs)
+    end
+    
+    unless skills_found
+      raise "No skills found in repository. Looking for directories named 'skills/' containing SKILL.md files."
+    end
+  end
+
+  # Install skills from a specific skills directory
+  private def install_skills_from_directory(skills_dir, skill_dirs)
+    skill_dirs.each do |skill_dir|
+      skill_name = File.basename(skill_dir)
+      target_path = File.join(@target_dir, skill_name)
+      
+      begin
+        # Create target directory
+        FileUtils.mkdir_p(@target_dir)
+        
+        # Check if skill already exists
+        if File.exist?(target_path)
+          puts "⚠️  Skill '#{skill_name}' already exists, skipping..."
+          @errors << "Skill '#{skill_name}' already exists at #{target_path}"
+          next
+        end
+        
+        # Copy skill directory
+        FileUtils.cp_r(skill_dir, target_path)
+        
+        # Read skill description from SKILL.md
+        description = extract_description(File.join(target_path, 'SKILL.md'))
+        
+        @installed_skills << {
+          name: skill_name,
+          path: target_path,
+          description: description
+        }
+        
+      rescue StandardError => e
+        @errors << "Failed to install '#{skill_name}': #{e.message}"
+      end
+    end
+  end
+
+  # Extract description from SKILL.md frontmatter
+  private def extract_description(skill_file)
+    return "No description" unless File.exist?(skill_file)
+    
+    content = File.read(skill_file)
+    
+    # Parse YAML frontmatter
+    if content =~ /\A---\s*\n(.*?)\n---/m
+      frontmatter = $1
+      if frontmatter =~ /^description:\s*(.+)$/
+        return $1.strip
+      end
+    end
+    
+    "No description"
+  rescue StandardError
+    "No description"
+  end
+
+  # Report installation results
+  private def report_results
+    puts "\n" + "=" * 60
+    
+    if @installed_skills.empty?
+      puts "❌ No skills were installed."
+      
+      if @errors.any?
+        puts "\nErrors encountered:"
+        @errors.each { |err| puts "   • #{err}" }
+      end
+      
+      exit 1
+    end
+    
+    puts "✅ Installation complete!"
+    puts "\nInstalled #{@installed_skills.size} skill(s):\n\n"
+    
+    @installed_skills.each do |skill|
+      puts "   ✓ #{skill[:name]}"
+      puts "     #{skill[:description]}"
+      puts "     → #{skill[:path]}"
+      puts
+    end
+    
+    if @errors.any?
+      puts "⚠️  Warnings:"
+      @errors.each { |err| puts "   • #{err}" }
+      puts
+    end
+    
+    puts "You can now use these skills with /skill-name"
+    puts "=" * 60
+  end
+end
+
+# Run installer if called directly
+if __FILE__ == $0
+  if ARGV.empty?
+    puts "Usage: ruby install_from_github.rb <github_url>"
+    puts "\nExamples:"
+    puts "  ruby install_from_github.rb https://github.com/username/repo"
+    puts "  ruby install_from_github.rb https://github.com/username/repo.git"
+    exit 1
+  end
+  
+  installer = SkillInstaller.new(ARGV[0])
+  installer.install
+end

data/lib/clacky/providers.rb

@@ -11,28 +11,21 @@ module Clacky
     # - api: API type (anthropic-messages, openai-responses, openai-completions)
     # - default_model: Recommended default model
     PRESETS = {
-      "anthropic" => {
-        "name" => "Anthropic (Claude)",
-        "base_url" => "https://api.anthropic.com",
-        "api" => "anthropic-messages",
-        "default_model" => "claude-sonnet-4-6",
-        "models" => ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4"]
-      }.freeze,
 
       "openrouter" => {
         "name" => "OpenRouter",
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
-        "default_model" => "anthropic/claude-sonnet-4-5",
+        "default_model" => "anthropic/claude-sonnet-4-6",
         "models" => []  # Dynamic - fetched from API
       }.freeze,
 
       "minimax" => {
         "name" => "Minimax",
-        "base_url" => "https://api.minimax.chat/v1",
+        "base_url" => "https://api.minimaxi.com/v1",
         "api" => "openai-completions",
-        "default_model" => "MiniMax-Text-01",
-        "models" => ["MiniMax-Text-01", "MiniMax-M2"]
+        "default_model" => "MiniMax-M2.5",
+        "models" => ["MiniMax-M2.1", "MiniMax-M2.5"]
       }.freeze,
 
       "kimi" => {
@@ -41,7 +34,16 @@ module Clacky
         "api" => "openai-completions",
         "default_model" => "kimi-k2.5",
         "models" => ["kimi-k2.5"]
+      }.freeze,
+
+      "anthropic" => {
+        "name" => "Anthropic (Claude)",
+        "base_url" => "https://api.anthropic.com",
+        "api" => "anthropic-messages",
+        "default_model" => "claude-sonnet-4.6",
+        "models" => ["claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"]
       }.freeze
+
     }.freeze
 
     class << self

data/lib/clacky/tools/invoke_skill.rb

@@ -55,9 +55,13 @@ module Clacky
         else
           # Expand skill content inline
           expanded = skill.process_content(task)
+          
+          # Add skill directory path information for script execution
+          skill_dir_info = "\n\n---\n**Skill Directory:** `#{skill.directory}`\n\nWhen executing scripts from Supporting Files, use the full path:\n`#{skill.directory}/scripts/script_name`\n---\n"
+          
           {
             message: "Skill '#{skill_name}' content expanded",
-            content: expanded,
+            content: expanded + skill_dir_info,
             skill_type: "inline",
             note: "The expanded content has been added to the conversation. Continue following its instructions."
           }

data/lib/clacky/tools/safe_shell.rb

@@ -32,7 +32,7 @@ module Clacky
         required: ["command"]
       }
 
-      def execute(command:, timeout: nil, max_output_lines: 1000, skip_safety_check: false)
+      def execute(command:, timeout: nil, max_output_lines: 1000, skip_safety_check: false, output_buffer: nil)
         # Get project root directory
         project_root = Dir.pwd
 
@@ -58,7 +58,7 @@ module Clacky
           hard_timeout = calculate_hard_timeout(command, timeout)
 
           # 4. Call parent class execution method
-          result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
+          result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines, output_buffer: output_buffer)
 
           # 5. Enhance result information
           enhance_result(result, command, safe_command, safety_replacer)

data/lib/clacky/tools/shell.rb

@@ -57,7 +57,7 @@ module Clacky
         'go build'
       ].freeze
 
-      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000)
+      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000, output_buffer: nil)
         require "open3"
         require "stringio"
 
@@ -67,6 +67,15 @@ module Clacky
         stderr_buffer = StringIO.new
         soft_timeout_triggered = false
         process_pid = nil
+        
+        # Store output buffer reference for real-time access (use LimitStack for memory efficiency)
+        @output_buffer = output_buffer
+        if @output_buffer
+          @output_buffer[:stdout_lines] = Utils::LimitStack.new(max_size: 1000)
+          @output_buffer[:stderr_lines] = Utils::LimitStack.new(max_size: 200)
+        end
+        @stdout_buffer = stdout_buffer
+        @stderr_buffer = stderr_buffer
 
         begin
           Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
@@ -126,6 +135,8 @@ module Clacky
                         else
                           stderr_buffer.write(data)
                         end
+                        # Update shared output buffer for real-time access
+                        update_output_buffer
                       rescue IO::WaitReadable, EOFError
                       end
                     end
@@ -306,7 +317,7 @@ module Clacky
 
       # Format result for LLM consumption - limit output size to save tokens
       # Maximum characters to include in LLM output
-      MAX_LLM_OUTPUT_CHARS = 1000
+      MAX_LLM_OUTPUT_CHARS = 4000
 
       def format_result_for_llm(result)
         # Return error info as-is if command failed or timed out
@@ -367,45 +378,62 @@ module Clacky
         # Write full output to temp file
         File.write(temp_file, output)
 
-        # For LLM display: show first and last lines to preserve structure
+        # For LLM display: show first N lines to preserve most useful information
         lines = output.lines
         return { content: output, temp_file: nil } if lines.length <= 2
 
-        # Reserve 60 chars for truncation notice
-        available_chars = max_chars - 60
+        # Reserve space for truncation notice (including temp file path)
+        notice_overhead = 200
+        available_chars = max_chars - notice_overhead
 
-        # Take first few lines
+        # Prioritize first lines as they usually contain the most important information
         first_part = []
         accumulated = 0
         lines.each do |line|
-          break if accumulated + line.length > available_chars / 2
+          break if accumulated + line.length > available_chars
           first_part << line
           accumulated += line.length
         end
 
-        # Take last few lines
-        last_part = []
-        accumulated = 0
-        lines.reverse_each do |line|
-          break if accumulated + line.length > available_chars / 2
-          last_part.unshift(line)
-          accumulated += line.length
-        end
-
         total_lines = lines.length
+        shown_lines = first_part.length
 
-        # Create notice message based on label
+        # Create prominent notice message with temp file path
         if label == "stderr"
-          notice = "... [Error output truncated for LLM: showing #{first_part.length} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ..."
+          notice = <<~NOTICE
+
+            ... [Error output truncated for LLM: showing #{shown_lines} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ...
+          NOTICE
         else
-          notice = "... [Output truncated for LLM: showing #{first_part.length} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ..."
+          notice = <<~NOTICE
+
+            ... [Output truncated for LLM: showing #{shown_lines} of #{total_lines} lines, full content: #{temp_file} (use grep to search)] ...
+          NOTICE
         end
 
         # Combine with compact notice
-        content = first_part.join + "\n#{notice}\n" + last_part.join
+        content = first_part.join + notice
 
         { content: content, temp_file: temp_file }
       end
+
+      # Update shared output buffer for real-time access
+      # Uses LimitStack to automatically manage memory and keep only recent output
+      private def update_output_buffer
+        return unless @output_buffer
+
+        # Push new lines to LimitStack (automatically handles size limit)
+        stdout_lines = @stdout_buffer.string.lines
+        stderr_lines = @stderr_buffer.string.lines
+        
+        @output_buffer[:stdout_lines].clear
+        @output_buffer[:stdout_lines].push_lines(stdout_lines)
+        
+        @output_buffer[:stderr_lines].clear
+        @output_buffer[:stderr_lines].push_lines(stderr_lines)
+        
+        @output_buffer[:timestamp] = Time.now
+      end
     end
   end
 end

data/lib/clacky/ui2/components/input_area.rb

@@ -1058,15 +1058,33 @@ module Clacky
         end
 
         # Render a segment of a line with cursor if cursor is in this segment
+        # Applies theme colors to the text
         # @param line [String] Full line text
         # @param segment_start [Integer] Start position of segment in line (char index)
         # @param segment_end [Integer] End position of segment in line (char index)
-        # @return [String] Rendered segment with cursor if applicable
+        # @return [String] Rendered segment with cursor and theme colors applied
         def render_line_segment_with_cursor(line, segment_start, segment_end)
-          # Delegate to LineEditor's shared implementation
-          rendered = super(line, segment_start, segment_end)
-          # Apply theme colors for InputArea
-          theme.format_text(rendered, :user)
+          chars = line.chars
+          segment_chars = chars[segment_start...segment_end]
+
+          # Check if cursor is in this segment
+          if @cursor_position >= segment_start && @cursor_position < segment_end
+            # Cursor is in this segment
+            cursor_pos_in_segment = @cursor_position - segment_start
+            before_cursor = segment_chars[0...cursor_pos_in_segment].join
+            cursor_char = segment_chars[cursor_pos_in_segment] || " "
+            after_cursor = segment_chars[(cursor_pos_in_segment + 1)..-1]&.join || ""
+
+            # Apply theme color to text parts, keep cursor highlight as is
+            "#{theme.format_text(before_cursor, :user)}#{@pastel.on_white(@pastel.black(cursor_char))}#{theme.format_text(after_cursor, :user)}"
+          elsif @cursor_position == segment_end && segment_end == line.length
+            # Cursor is at the very end of the line, show it in last segment
+            segment_text = segment_chars.join
+            "#{theme.format_text(segment_text, :user)}#{@pastel.on_white(@pastel.black(' '))}"
+          else
+            # Cursor is not in this segment, apply theme color
+            theme.format_text(segment_chars.join, :user)
+          end
         end
 
         # Render a separator line (ensures it doesn't exceed screen width)
@@ -1122,7 +1140,7 @@ module Clacky
           # Working directory (shortened if too long)
           if @sessionbar_info[:working_dir]
             dir_display = shorten_path(@sessionbar_info[:working_dir])
-            parts << @pastel.dim(@pastel.cyan(dir_display))
+            parts << theme.format_text(dir_display, :statusbar_path)
           end
 
           # Permission mode
@@ -1133,15 +1151,15 @@ module Clacky
 
           # Model
           if @sessionbar_info[:model]
-            parts << @pastel.dim(@pastel.white(@sessionbar_info[:model]))
+            parts << theme.format_text(@sessionbar_info[:model], :statusbar_secondary)
           end
 
           # Tasks count
-          parts << @pastel.dim(@pastel.white("#{@sessionbar_info[:tasks]} tasks"))
+          parts << theme.format_text("#{@sessionbar_info[:tasks]} tasks", :statusbar_secondary)
 
           # Cost
           cost_display = format("$%.1f", @sessionbar_info[:cost])
-          parts << @pastel.dim(@pastel.white(cost_display))
+          parts << theme.format_text(cost_display, :statusbar_secondary)
 
           " " + parts.join(separator)
         end

data/lib/clacky/ui2/components/modal_component.rb

@@ -30,8 +30,9 @@ module Clacky
         #   Example: [{ name: "Option 1", value: :opt1 }, { name: "---", disabled: true }]
         # @param validator [Proc, nil] Optional validation callback that receives values hash
         #                              Should return { success: true } or { success: false, error: "message" }
+        # @param on_close [Proc, nil] Optional callback to execute when modal closes (e.g., to re-render screen)
         # @return [Hash, nil] Hash of field values or selected value, or nil if cancelled
-        def show(title:, fields: nil, choices: nil, validator: nil)
+        def show(title:, fields: nil, choices: nil, validator: nil, on_close: nil)
           @title = title
           @mode = choices ? :menu : :form
           @fields = fields || []
@@ -45,10 +46,16 @@ module Clacky
             @selected_index = @choices.index { |c| !c[:disabled] } || 0
           end
 
-          # Adjust height for menu mode
+          # Adjust height based on mode
           if @mode == :menu
             visible_items = [@choices.length, 15].min
             @height = visible_items + 4  # +4 for title, borders, and instructions
+          else
+            # Form mode - adjust height based on number of fields
+            # Each field takes 2 rows (label + input)
+            # +3 for title and top border
+            # +5 for error message area, buttons, and bottom border
+            @height = (@fields.length * 2) + 3 + 5
           end
 
           # Get terminal size
@@ -69,6 +76,8 @@ module Clacky
           ensure
             # Clear modal area
             clear_modal(start_row, start_col)
+            # Call on_close callback if provided (e.g., to re-render screen)
+            on_close&.call
           end
         end
 
@@ -167,6 +176,17 @@ module Clacky
               # Clear testing messages
               print "\e[#{testing_row};#{testing_col}H\e[K"
               print "\e[#{testing_row + 1};#{testing_col}H\e[K"
+              
+              if validation_result[:success]
+                # Validation passed - hide cursor and return values
+                print "\e[?25l"
+                return @values
+              else
+                # Validation failed - show error and loop again to let user correct input
+                @error_message = validation_result[:error] || "Validation failed"
+                # Don't clear modal - just loop again to redraw with error message
+                # This prevents the modal from flickering
+              end
             else
               # No validator - return immediately
               print "\e[?25l"

data/lib/clacky/ui2/components/welcome_banner.rb

@@ -26,26 +26,48 @@ module Clacky
           "[*] Type /help for more commands"
         ].freeze
 
+        # Minimum terminal width required for full logo display
+        MIN_WIDTH_FOR_LOGO = 90
+
         def initialize
           @pastel = Pastel.new
         end
 
-        # Render only the logo (ASCII art)
+        # Get current theme from ThemeManager
+        def theme
+          UI2::ThemeManager.current_theme
+        end
+
+        # Render only the logo (ASCII art or simple text based on terminal width)
+        # @param width [Integer] Terminal width
         # @return [String] Formatted logo only
-        def render_logo
+        def render_logo(width:)
           lines = []
           lines << ""
-          lines << @pastel.bright_green(LOGO)
+          
+          if width >= MIN_WIDTH_FOR_LOGO
+            lines << @pastel.bright_green(LOGO)
+          else
+            lines << @pastel.bright_green("Welcome, OpenClacky is here")
+          end
+          
           lines << ""
           lines.join("\n")
         end
 
         # Render startup banner
+        # @param width [Integer] Terminal width
         # @return [String] Formatted startup banner
-        def render_startup
+        def render_startup(width:)
           lines = []
           lines << ""
-          lines << @pastel.bright_green(LOGO)
+          
+          if width >= MIN_WIDTH_FOR_LOGO
+            lines << @pastel.bright_green(LOGO)
+          else
+            lines << @pastel.bright_green("Welcome, OpenClacky is here")
+          end
+          
           lines << ""
           lines << @pastel.bright_cyan(TAGLINE)
           lines << @pastel.dim("    Version #{Clacky::VERSION}")
@@ -71,7 +93,7 @@ module Clacky
           lines << info_line("Working Directory", working_dir)
           lines << info_line("Permission Mode", mode)
           lines << ""
-          lines << @pastel.dim("[!] Type 'exit' or 'quit' to terminate session")
+          lines << theme.format_text("[!] Type 'exit' or 'quit' to terminate session", :thinking)
           lines << separator("-")
           lines << ""
           lines.join("\n")
@@ -80,9 +102,10 @@ module Clacky
         # Render full welcome (startup + agent info)
         # @param working_dir [String] Working directory
         # @param mode [String] Permission mode
+        # @param width [Integer] Terminal width
         # @return [String] Full welcome content
-        def render_full(working_dir:, mode:)
-          render_startup + render_agent_welcome(
+        def render_full(working_dir:, mode:, width:)
+          render_startup(width: width) + render_agent_welcome(
             working_dir: working_dir,
             mode: mode
           )
@@ -92,12 +115,12 @@ module Clacky
 
         def info_line(label, value)
           label_text = @pastel.cyan("[#{label}]")
-          value_text = @pastel.white(value)
+          value_text = theme.format_text(value, :info)
           "    #{label_text} #{value_text}"
         end
 
         def separator(char = "-")
-          @pastel.dim(char * 80)
+          theme.format_text(char * 80, :thinking)  # Use :thinking for subtle separator
         end
       end
     end