openclacky 0.7.0 → 0.7.2

data/lib/clacky/default_skills/deploy/tools/fetch_runtime_logs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Clacky
+  module DeployTools
+    # Fetch runtime logs from deployed service
+    class FetchRuntimeLogs
+      DEFAULT_LINES = 100
+      MAX_LINES = 1000
+
+      # Fetch runtime logs
+      #
+      # @param service_name [String] Service to fetch logs from
+      # @param lines [Integer] Number of lines to fetch (default: 100)
+      # @return [Hash] Result containing logs
+      def self.execute(service_name:, lines: DEFAULT_LINES)
+        if service_name.nil? || service_name.empty?
+          return {
+            error: "Service name is required",
+            details: "Please provide a valid service name"
+          }
+        end
+
+        # Validate lines parameter
+        lines = lines.to_i
+        if lines <= 0 || lines > MAX_LINES
+          return {
+            error: "Invalid lines parameter",
+            details: "Lines must be between 1 and #{MAX_LINES}",
+            provided: lines
+          }
+        end
+
+        puts "📋 Fetching #{lines} lines of logs for service: #{service_name}"
+
+        # Execute command
+        command = "clackycli logs -s #{shell_escape(service_name)} --lines #{lines}"
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code != 0
+          return {
+            error: "Failed to fetch logs",
+            details: output,
+            exit_code: exit_code,
+            service: service_name
+          }
+        end
+
+        {
+          success: true,
+          service: service_name,
+          lines_requested: lines,
+          logs: output,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # Escape shell arguments
+      #
+      # @param str [String] String to escape
+      # @return [String] Escaped string
+      def self.shell_escape(str)
+        "'#{str.gsub("'", "'\\\\''")}'"
+      end
+    end
+  end
+end

data/lib/clacky/default_skills/deploy/tools/list_services.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Clacky
+  module DeployTools
+    # List Railway services with environment variables (sensitive data masked)
+    class ListServices
+      SENSITIVE_PATTERNS = [
+        /password/i,
+        /secret/i,
+        /api_key/i,
+        /token/i,
+        /credential/i,
+        /private_key/i
+      ].freeze
+
+      # Execute the list_services command
+      #
+      # @return [Hash] Result containing services array
+      def self.execute
+        output = `clackycli service list --json 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code != 0
+          return {
+            error: "Failed to list services",
+            details: output,
+            exit_code: exit_code
+          }
+        end
+
+        begin
+          services = JSON.parse(output)
+          masked_services = mask_sensitive_data(services)
+          
+          {
+            success: true,
+            services: masked_services,
+            count: masked_services.length
+          }
+        rescue JSON::ParserError => e
+          {
+            error: "Failed to parse Railway CLI output",
+            details: e.message,
+            raw_output: output
+          }
+        end
+      end
+
+      # Mask sensitive environment variable values
+      #
+      # @param services [Array<Hash>] Array of service objects
+      # @return [Array<Hash>] Services with masked sensitive data
+      def self.mask_sensitive_data(services)
+        services.map do |service|
+          service = service.dup
+          
+          if service['variables']
+            service['variables'] = mask_variables(service['variables'])
+          end
+          
+          service
+        end
+      end
+
+      # Mask sensitive variable values
+      #
+      # @param variables [Hash] Environment variables
+      # @return [Hash] Variables with sensitive values masked
+      def self.mask_variables(variables)
+        variables.transform_values do |value|
+          next value unless value.is_a?(String)
+          
+          # Check if variable name matches sensitive patterns
+          is_sensitive = SENSITIVE_PATTERNS.any? { |pattern| value =~ pattern }
+          is_sensitive ? '******' : value
+        end
+      end
+    end
+  end
+end

data/lib/clacky/default_skills/deploy/tools/report_deploy_status.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Clacky
+  module DeployTools
+    # Report deployment status to user with formatted output
+    class ReportDeployStatus
+      VALID_STATUSES = %w[analyzing deploying checking success failed].freeze
+      
+      STATUS_ICONS = {
+        'analyzing' => '🔍',
+        'deploying' => '🚀',
+        'checking' => '✅',
+        'success' => '🎉',
+        'failed' => '❌'
+      }.freeze
+
+      STATUS_COLORS = {
+        'analyzing' => :cyan,
+        'deploying' => :yellow,
+        'checking' => :blue,
+        'success' => :green,
+        'failed' => :red
+      }.freeze
+
+      # Execute the report_deploy_status command
+      #
+      # @param status [String] Deployment status (analyzing, deploying, checking, success, failed)
+      # @param message [String] Status message to display
+      # @return [Hash] Result of the report operation
+      def self.execute(status:, message:)
+        unless VALID_STATUSES.include?(status)
+          return {
+            error: "Invalid status",
+            details: "Status must be one of: #{VALID_STATUSES.join(', ')}",
+            provided: status
+          }
+        end
+
+        icon = STATUS_ICONS[status]
+        formatted_message = format_message(status, message, icon)
+        
+        # Output to stdout
+        puts formatted_message
+        
+        {
+          success: true,
+          status: status,
+          message: message,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # Format the status message with icon and styling
+      #
+      # @param status [String] Deployment status
+      # @param message [String] Status message
+      # @param icon [String] Emoji icon for status
+      # @return [String] Formatted message
+      def self.format_message(status, message, icon)
+        timestamp = Time.now.strftime("%H:%M:%S")
+        status_label = status.upcase.ljust(10)
+        
+        "#{icon} [#{timestamp}] #{status_label} #{message}"
+      end
+    end
+  end
+end

data/lib/clacky/default_skills/deploy/tools/set_deploy_variables.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Clacky
+  module DeployTools
+    # Set environment variables for a Railway service
+    class SetDeployVariables
+      PROTECTED_PREFIXES = ['CLACKY_'].freeze
+      
+      SENSITIVE_PATTERNS = [
+        /password/i,
+        /secret/i,
+        /api_key/i,
+        /token/i,
+        /credential/i,
+        /private_key/i
+      ].freeze
+
+      # Execute the set_deploy_variables command
+      #
+      # @param service_name [String] Target service name
+      # @param variables [Hash] Simple variables (KEY => VALUE)
+      # @param ref_variables [Hash] Reference variables (KEY => SERVICE.VAR)
+      # @return [Hash] Result of the operation
+      def self.execute(service_name:, variables: {}, ref_variables: {})
+        # Validate service name
+        if service_name.nil? || service_name.empty?
+          return {
+            error: "Service name is required",
+            details: "Please provide a valid service name"
+          }
+        end
+
+        results = {
+          success: true,
+          service: service_name,
+          set_variables: [],
+          skipped_variables: [],
+          errors: []
+        }
+
+        # Set simple variables
+        variables.each do |key, value|
+          result = set_variable(service_name, key, value, is_reference: false)
+          if result[:success]
+            results[:set_variables] << { key: key, type: 'simple' }
+          elsif result[:skipped]
+            results[:skipped_variables] << { key: key, reason: result[:reason] }
+          else
+            results[:errors] << { key: key, error: result[:error] }
+          end
+        end
+
+        # Set reference variables
+        ref_variables.each do |key, reference|
+          result = set_variable(service_name, key, reference, is_reference: true)
+          if result[:success]
+            results[:set_variables] << { key: key, type: 'reference' }
+          elsif result[:skipped]
+            results[:skipped_variables] << { key: key, reason: result[:reason] }
+          else
+            results[:errors] << { key: key, error: result[:error] }
+          end
+        end
+
+        # Overall success if no errors occurred
+        results[:success] = results[:errors].empty?
+        results
+      end
+
+      # Set a single environment variable
+      #
+      # @param service_name [String] Service name
+      # @param key [String] Variable name
+      # @param value [String] Variable value or reference
+      # @param is_reference [Boolean] Whether this is a reference variable
+      # @return [Hash] Result of setting the variable
+      def self.set_variable(service_name, key, value, is_reference:)
+        # Skip protected variables
+        if protected_variable?(key)
+          return {
+            success: false,
+            skipped: true,
+            reason: "Protected system variable (#{key})"
+          }
+        end
+
+        # Build the command
+        if is_reference
+          command = "clackycli variables -s #{shell_escape(service_name)} --set-ref #{shell_escape(key)}=#{shell_escape(value)}"
+        else
+          command = "clackycli variables -s #{shell_escape(service_name)} --set #{shell_escape(key)}=#{shell_escape(value)}"
+        end
+
+        # Log (with sensitive masking)
+        log_value = sensitive_variable?(key) ? '******' : value
+        puts "Setting #{key}=#{log_value} on service #{service_name}"
+
+        # Execute command
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code == 0
+          { success: true }
+        else
+          {
+            success: false,
+            skipped: false,
+            error: output.strip
+          }
+        end
+      end
+
+      # Check if a variable is protected
+      #
+      # @param key [String] Variable name
+      # @return [Boolean] True if protected
+      def self.protected_variable?(key)
+        PROTECTED_PREFIXES.any? { |prefix| key.start_with?(prefix) }
+      end
+
+      # Check if a variable is sensitive
+      #
+      # @param key [String] Variable name
+      # @return [Boolean] True if sensitive
+      def self.sensitive_variable?(key)
+        SENSITIVE_PATTERNS.any? { |pattern| key =~ pattern }
+      end
+
+      # Escape shell arguments
+      #
+      # @param str [String] String to escape
+      # @return [String] Escaped string
+      def self.shell_escape(str)
+        "'#{str.gsub("'", "'\\\\''")}'"
+      end
+    end
+  end
+end

data/lib/clacky/default_skills/new/SKILL.md

@@ -36,7 +36,7 @@ cd <project_name>
 
 ### 5. Success Message
 Tell user:
-- ✅ Project created successfully!
+- Project created successfully!
 - Next step: enter project directory to start development
 - Command: `cd <project_name>`
 
@@ -52,4 +52,4 @@ Response:
 1. Creating a new project named "blog"
 2. Cloning template...
 3. Installing dependencies...
-4. ✅ Done! You can now: `cd blog` to start development
+4. Done! You can now: `cd blog` to start development

data/lib/clacky/json_ui_controller.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require_relative "ui_interface"
+
+module Clacky
+  # JsonUIController implements UIInterface for JSON (NDJSON) output mode.
+  # All output is written as one-JSON-per-line to stdout.
+  # Confirmation requests read responses from stdin.
+  class JsonUIController
+    include Clacky::UIInterface
+
+    def initialize(output: $stdout, input: $stdin)
+      @output = output
+      @input = input
+      @mutex = Mutex.new
+    end
+
+    # Emit a raw NDJSON event
+    def emit(type, **data)
+      event = { type: type }.merge(data)
+      @mutex.synchronize do
+        @output.puts(JSON.generate(event))
+        @output.flush
+      end
+    end
+
+    # === Output display ===
+
+    def show_user_message(content, images: [])
+      emit("user_message", content: content, images: images)
+    end
+
+    def show_assistant_message(content)
+      return if content.nil? || content.strip.empty?
+
+      emit("assistant_message", content: content)
+    end
+
+    def show_tool_call(name, args)
+      args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+      emit("tool_call", name: name, args: args_data)
+    end
+
+    def show_tool_result(result)
+      emit("tool_result", result: result)
+    end
+
+    def show_tool_error(error)
+      error_msg = error.is_a?(Exception) ? error.message : error.to_s
+      emit("tool_error", error: error_msg)
+    end
+
+    def show_tool_args(formatted_args)
+      emit("tool_args", args: formatted_args)
+    end
+
+    def show_file_write_preview(path, is_new_file:)
+      emit("file_preview", path: path, operation: "write", is_new_file: is_new_file)
+    end
+
+    def show_file_edit_preview(path)
+      emit("file_preview", path: path, operation: "edit")
+    end
+
+    def show_file_error(error_message)
+      emit("file_error", error: error_message)
+    end
+
+    def show_shell_preview(command)
+      emit("shell_preview", command: command)
+    end
+
+    def show_diff(old_content, new_content, max_lines: 50)
+      emit("diff", old_size: old_content.bytesize, new_size: new_content.bytesize)
+    end
+
+    def show_token_usage(token_data)
+      emit("token_usage", **token_data)
+    end
+
+    def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false)
+      data = { iterations: iterations, cost: cost }
+      data[:duration] = duration if duration
+      data[:cache_stats] = cache_stats if cache_stats
+      data[:awaiting_user_feedback] = awaiting_user_feedback if awaiting_user_feedback
+      emit("complete", **data)
+    end
+
+    # append_output is a no-op in JSON mode (content is already emitted via semantic methods)
+    def append_output(content)
+      # no-op
+    end
+
+    # === Status messages ===
+
+    def show_info(message, prefix_newline: true)
+      emit("info", message: message)
+    end
+
+    def show_warning(message)
+      emit("warning", message: message)
+    end
+
+    def show_error(message)
+      emit("error", message: message)
+    end
+
+    def show_success(message)
+      emit("success", message: message)
+    end
+
+    def log(message, level: :info)
+      emit("log", level: level.to_s, message: message)
+    end
+
+    # === Progress ===
+
+    def show_progress(message = nil, prefix_newline: true)
+      @progress_start_time = Time.now
+      emit("progress", message: message, status: "start")
+    end
+
+    def clear_progress
+      elapsed = @progress_start_time ? (Time.now - @progress_start_time).round(1) : 0
+      @progress_start_time = nil
+      emit("progress", status: "stop", elapsed: elapsed)
+    end
+
+    # === State updates ===
+
+    def update_sessionbar(tasks: nil, cost: nil, status: nil)
+      data = {}
+      data[:tasks] = tasks if tasks
+      data[:cost] = cost if cost
+      data[:status] = status if status
+      emit("session_update", **data) unless data.empty?
+    end
+
+    def update_todos(todos)
+      emit("todo_update", todos: todos)
+    end
+
+    def set_working_status
+      emit("session_update", status: "working")
+    end
+
+    def set_idle_status
+      emit("session_update", status: "idle")
+    end
+
+    # === Blocking interaction ===
+
+    def request_confirmation(message, default: true)
+      conf_id = "conf_#{SecureRandom.hex(4)}"
+      emit("request_confirmation", id: conf_id, message: message, default: default)
+
+      # Read response from stdin (blocking)
+      line = @input.gets
+      return default if line.nil?
+
+      begin
+        response = JSON.parse(line.strip)
+        result = response["result"] || response[:result]
+
+        case result.to_s.downcase
+        when "yes", "y" then true
+        when "no", "n" then false
+        else
+          # Return as feedback text
+          result.to_s
+        end
+      rescue JSON::ParserError
+        default
+      end
+    end
+
+    # === Input control (no-ops in JSON mode) ===
+
+    def clear_input
+      # no-op
+    end
+
+    def set_input_tips(message, type: :info)
+      # no-op
+    end
+
+    # === Lifecycle ===
+
+    def stop
+      # no-op
+    end
+  end
+end

data/lib/clacky/providers.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Built-in model provider presets
+  # Provides default configurations for supported AI model providers
+  module Providers
+    # Provider preset definitions
+    # Each preset includes:
+    # - name: Human-readable provider name
+    # - base_url: Default API endpoint
+    # - 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",
+        "models" => []  # Dynamic - fetched from API
+      }.freeze,
+
+      "minimax" => {
+        "name" => "Minimax",
+        "base_url" => "https://api.minimax.chat/v1",
+        "api" => "openai-completions",
+        "default_model" => "MiniMax-Text-01",
+        "models" => ["MiniMax-Text-01", "MiniMax-M2"]
+      }.freeze,
+
+      "kimi" => {
+        "name" => "Kimi (Moonshot)",
+        "base_url" => "https://api.moonshot.cn/v1",
+        "api" => "openai-completions",
+        "default_model" => "kimi-k2.5",
+        "models" => ["kimi-k2.5"]
+      }.freeze
+    }.freeze
+
+    class << self
+      # Check if a provider preset exists
+      # @param provider_id [String] The provider identifier (e.g., "anthropic", "openrouter")
+      # @return [Boolean] True if the preset exists
+      def exists?(provider_id)
+        PRESETS.key?(provider_id)
+      end
+
+      # Get a provider preset by ID
+      # @param provider_id [String] The provider identifier
+      # @return [Hash, nil] The preset configuration or nil if not found
+      def get(provider_id)
+        PRESETS[provider_id]
+      end
+
+      # Get the default model for a provider
+      # @param provider_id [String] The provider identifier
+      # @return [String, nil] The default model name or nil if provider not found
+      def default_model(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("default_model")
+      end
+
+      # Get the base URL for a provider
+      # @param provider_id [String] The provider identifier
+      # @return [String, nil] The base URL or nil if provider not found
+      def base_url(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("base_url")
+      end
+
+      # Get the API type for a provider
+      # @param provider_id [String] The provider identifier
+      # @return [String, nil] The API type or nil if provider not found
+      def api_type(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("api")
+      end
+
+      # List all available provider IDs
+      # @return [Array<String>] List of provider identifiers
+      def provider_ids
+        PRESETS.keys
+      end
+
+      # List all available providers with their names
+      # @return [Array<Array(String, String)>] Array of [id, name] pairs
+      def list
+        PRESETS.map { |id, config| [id, config["name"]] }
+      end
+
+      # Get available models for a provider
+      # @param provider_id [String] The provider identifier
+      # @return [Array<String>] List of model names (empty if dynamic)
+      def models(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("models") || []
+      end
+    end
+  end
+end