openclacky 0.7.0 → 0.7.2

data/lib/clacky/cli.rb

@@ -3,6 +3,7 @@
 require "thor"
 require "tty-prompt"
 require_relative "ui2"
+require_relative "json_ui_controller"
 
 module Clacky
   class CLI < Thor
@@ -13,7 +14,7 @@ module Clacky
     # Set agent as the default command
     default_task :agent
 
-    desc "agent [MESSAGE]", "Run agent in interactive mode with autonomous tool use (default)"
+    desc "agent", "Run agent in interactive mode with autonomous tool use (default)"
     long_desc <<-LONGDESC
       Run an AI agent in interactive mode that can autonomously use tools to complete tasks.
 
@@ -24,7 +25,6 @@ module Clacky
       Permission modes:
         auto_approve    - Automatically execute all tools (use with caution)
         confirm_safes   - Auto-approve safe operations, confirm risky ones (default)
-        confirm_edits   - Auto-approve read-only tools, confirm edits
         plan_only       - Generate plan without executing
 
       UI themes:
@@ -40,7 +40,7 @@ module Clacky
         $ clacky agent --mode=auto_approve --path /path/to/project
     LONGDESC
     option :mode, type: :string, default: "confirm_safes",
-           desc: "Permission mode: auto_approve, confirm_safes, confirm_edits, plan_only"
+           desc: "Permission mode: auto_approve, confirm_safes, plan_only"
     option :theme, type: :string, default: "hacker",
            desc: "UI theme: hacker, minimal (default: hacker)"
     option :verbose, type: :boolean, aliases: "-v", default: false, desc: "Show detailed output"
@@ -48,14 +48,15 @@ module Clacky
     option :continue, type: :boolean, aliases: "-c", desc: "Continue most recent session"
     option :list, type: :boolean, aliases: "-l", desc: "List recent sessions"
     option :attach, type: :string, aliases: "-a", desc: "Attach to session by number or keyword"
+    option :json, type: :boolean, default: false, desc: "Output NDJSON to stdout (for scripting/piping)"
     option :help, type: :boolean, aliases: "-h", desc: "Show this help message"
-    def agent(message = nil)
+    def agent
       # Handle help option
       if options[:help]
         invoke :help, ["agent"]
         return
       end
-      config = Clacky::Config.load
+      agent_config = Clacky::AgentConfig.load
 
       # Handle session listing
       if options[:list]
@@ -71,9 +72,12 @@ module Clacky
       # Validate and get working directory
       working_dir = validate_working_directory(options[:path])
 
-      # Build agent config
-      agent_config = build_agent_config(config)
-      client = Clacky::Client.new(config.api_key, base_url: config.base_url, anthropic_format: config.anthropic_format?)
+      # Update agent config with CLI options
+      agent_config.permission_mode = options[:mode].to_sym if options[:mode]
+      agent_config.verbose = options[:verbose] if options[:verbose]
+
+      # Create client for current model
+      client = Clacky::Client.new(agent_config.api_key, base_url: agent_config.base_url, anthropic_format: agent_config.anthropic_format?)
 
       # Handle session loading/continuation
       session_manager = Clacky::SessionManager.new
@@ -95,90 +99,126 @@ module Clacky
       original_dir = Dir.pwd
       should_chdir = File.realpath(working_dir) != File.realpath(original_dir)
       Dir.chdir(working_dir) if should_chdir
-
       begin
-        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client, is_session_load: is_session_load)
-      rescue StandardError => e
-        # Save session on error
-        if session_manager
-          session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
-        end
-
-        # Report the error
-        say "\n❌ Error: #{e.message}", :red
-        say e.backtrace.first(5).join("\n"), :red if options[:verbose]
-
-        # Show session saved message
-        if session_manager&.last_saved_path
-          say "\n📂 Session saved: #{session_manager.last_saved_path}", :yellow
+        if options[:json]
+          run_agent_with_json(agent, working_dir, agent_config, session_manager, client)
+        else
+          run_agent_with_ui2(agent, working_dir, agent_config, session_manager, client, is_session_load: is_session_load)
         end
-
-        # Guide user to recover
-        say "\n💡 To recover and retry, run:", :yellow
-        say "   clacky agent -c", :cyan
-
-        exit 1
       ensure
         Dir.chdir(original_dir)
       end
     end
 
     no_commands do
-      private def handle_config_command(ui_controller, client, agent_config)
-        config = Clacky::Config.load
+      private def handle_config_command(ui_controller, client, agent_config, agent)
+        config = agent_config
 
         # Create test callback
         test_callback = lambda do |test_config|
           # Create a temporary client with new config to test
           test_client = Clacky::Client.new(
-            test_config.api_key, 
-            base_url: test_config.base_url, 
+            test_config.api_key,
+            base_url: test_config.base_url,
             anthropic_format: test_config.anthropic_format?
           )
-          
+
           # Test connection
-          test_client.test_connection(model: test_config.model)
+          test_client.test_connection(model: test_config.model_name)
         end
 
         # Show modal dialog for configuration with test callback
         result = ui_controller.show_config_modal(config, test_callback: test_callback)
 
-        # If user cancelled, return early
+        # If user closed modal without changes, return early
         if result.nil?
-          ui_controller.show_warning("Configuration cancelled")
           return
         end
 
-        # Update config with non-empty values
-        config.api_key = result[:api_key] unless result[:api_key].to_s.empty?
-        config.model = result[:model] unless result[:model].to_s.empty?
-        config.base_url = result[:base_url] unless result[:base_url].to_s.empty?
-
-        # Save configuration (only reached if test passed)
-        config.save
-
-        # Update client with new config
+        # Config was changed (either switch or edit), update client, agent, and UI
+        # Update client with current model's config
         client.instance_variable_set(:@api_key, config.api_key)
         client.instance_variable_set(:@base_url, config.base_url)
+        client.instance_variable_set(:@use_anthropic_format, config.anthropic_format?)
+
+        # Update agent's client (agent has its own @client instance variable)
+        agent.instance_variable_set(:@client, Clacky::Client.new(
+          config.api_key,
+          base_url: config.base_url,
+          anthropic_format: config.anthropic_format?
+        ))
+
+        # Update agent's message compressor with new client
+        agent.instance_variable_set(:@message_compressor,
+          Clacky::MessageCompressor.new(agent.instance_variable_get(:@client), model: config.model_name)
+        )
 
-        # Update agent config model
-        agent_config.model = config.model
+        # Update UI controller's model display
+        ui_controller.config[:model] = config.model_name
+        ui_controller.update_sessionbar(
+          tasks: agent.total_tasks,
+          cost: agent.total_cost
+        )
 
         # Show success message in output
         masked_key = "#{config.api_key[0..7]}#{'*' * 20}#{config.api_key[-4..]}"
-        ui_controller.show_success("Configuration saved successfully!")
+        ui_controller.show_success("Configuration updated!")
+        ui_controller.append_output("  Current Model: #{config.model_name}")
         ui_controller.append_output("  API Key: #{masked_key}")
-        ui_controller.append_output("  Model: #{config.model}")
         ui_controller.append_output("  Base URL: #{config.base_url}")
+        ui_controller.append_output("  Format: #{config.anthropic_format? ? 'Anthropic' : 'OpenAI'}")
         ui_controller.append_output("")
       end
 
-      private def build_agent_config(config)
-        AgentConfig.new(
-          model: options[:model] || config.model,
-          permission_mode: options[:mode].to_sym,
-          verbose: options[:verbose]
-        )
+      private def handle_time_machine_command(ui_controller, agent, session_manager)
+        # Get task history from agent
+        history = agent.get_task_history(limit: 10)
+
+        if history.empty?
+          ui_controller.show_info("No task history available yet.")
+          return
+        end
+
+        # Show time machine menu
+        selected_task_id = ui_controller.show_time_machine_menu(history)
+
+        # If user cancelled, return
+        return if selected_task_id.nil?
+
+        # Get current active task for comparison
+        current_task_id = agent.instance_variable_get(:@active_task_id)
+
+        # Perform the switch
+        begin
+          if selected_task_id < current_task_id
+            # Undo to selected task
+            ui_controller.show_info("Undoing to Task #{selected_task_id}...")
+            result = agent.switch_to_task(selected_task_id)
+            if result[:success]
+              ui_controller.show_success("✓ #{result[:message]}")
+            else
+              ui_controller.show_error(result[:message])
+              return
+            end
+          else
+            # Redo to selected task
+            ui_controller.show_info("Redoing to Task #{selected_task_id}...")
+            result = agent.switch_to_task(selected_task_id)
+            if result[:success]
+              ui_controller.show_success("✓ #{result[:message]}")
+            else
+              ui_controller.show_error(result[:message])
+              return
+            end
+          end
+
+          # Save session after switch
+          if session_manager
+            session_manager.save(agent.to_session_data(status: :success))
+          end
+        rescue StandardError => e
+          ui_controller.show_error("Time Machine failed: #{e.message}")
+        end
       end
 
       def validate_working_directory(path)
@@ -218,7 +258,7 @@ module Clacky
           session_id = session[:session_id][0..7]
           tasks = session.dig(:stats, :total_tasks) || 0
           cost = session.dig(:stats, :total_cost_usd) || 0.0
-          first_msg = session[:first_user_message] || "No message"
+          last_msg = session[:last_user_message] || "No message"
           is_current_dir = session[:working_dir] == working_dir
 
           dir_marker = is_current_dir ? "📍" : "  "
@@ -272,8 +312,8 @@ module Clacky
             matching_sessions.each_with_index do |session, idx|
               created_at = Time.parse(session[:created_at]).strftime("%Y-%m-%d %H:%M")
               session_id = session[:session_id][0..7]
-              first_msg = session[:first_user_message] || "No message"
-              say "  #{idx + 1}. [#{session_id}] #{created_at} - #{first_msg}", :cyan
+              last_msg = session[:last_user_message] || "No message"
+              say "  #{idx + 1}. [#{session_id}] #{created_at} - #{last_msg}", :cyan
             end
             say "\nPlease use a more specific prefix.", :yellow
             exit 1
@@ -288,7 +328,7 @@ module Clacky
 
       # Handle agent error/interrupt with cleanup
       def handle_agent_exception(ui_controller, agent, session_manager, exception)
-        ui_controller.stop_progress_thread
+        ui_controller.clear_progress
         ui_controller.set_idle_status
 
         if exception.is_a?(Clacky::AgentInterrupted)
@@ -301,8 +341,89 @@ module Clacky
         end
       end
 
+      # Run agent with JSON (NDJSON) output mode — persistent process.
+      # Reads JSON messages from stdin, writes NDJSON events to stdout.
+      # Stays alive until "/exit", {"type":"exit"}, or stdin EOF.
+      #
+      # Input protocol (one JSON per line on stdin):
+      #   {"type":"message","content":"..."}          — run agent with this message
+      #   {"type":"message","content":"...","images":["path"]} — with images
+      #   {"type":"exit"}                             — graceful shutdown
+      #   {"type":"confirmation","id":"conf_1","result":"yes"} — answer to request_confirmation
+      #
+      # If a bare string line is received it is treated as a message content.
+      def run_agent_with_json(agent, working_dir, agent_config, session_manager, client)
+        json_ui = Clacky::JsonUIController.new
+        agent.instance_variable_set(:@ui, json_ui)
+
+        json_ui.emit("system", message: "Agent started", model: agent_config.model_name, working_dir: working_dir)
+
+        # Persistent input loop — read JSON lines from stdin
+        while (line = $stdin.gets)
+          line = line.strip
+          next if line.empty?
+
+          # Parse input
+          input = begin
+                    JSON.parse(line)
+                  rescue JSON::ParserError
+                    # Treat bare string as a message
+                    { "type" => "message", "content" => line }
+                  end
+
+          type = input["type"] || "message"
+
+          case type
+          when "message"
+            content = input["content"].to_s.strip
+            if content.empty?
+              json_ui.emit("error", message: "Empty message content")
+              next
+            end
+
+            # Handle built-in commands
+            case content.downcase
+            when "/exit", "/quit"
+              break
+            when "/clear"
+              agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir)
+              agent.instance_variable_set(:@ui, json_ui)
+              json_ui.emit("info", message: "Session cleared. Starting fresh.")
+              next
+            end
+
+            images = input["images"] || []
+            run_json_task(agent, json_ui, session_manager) { agent.run(content, images: images) }
+          when "exit"
+            break
+          else
+            json_ui.emit("error", message: "Unknown input type: #{type}")
+          end
+        end
+
+        # Final session save and shutdown
+        if session_manager && agent.total_tasks > 0
+          session_manager.save(agent.to_session_data(status: :exited))
+        end
+        json_ui.emit("done", total_cost: agent.total_cost, total_tasks: agent.total_tasks)
+      end
+
+      # Execute a single agent task inside the JSON loop, with error handling.
+      def run_json_task(agent, json_ui, session_manager)
+        json_ui.set_working_status
+        yield
+        session_manager&.save(agent.to_session_data(status: :success))
+        json_ui.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+      rescue Clacky::AgentInterrupted
+        json_ui.emit("interrupted")
+      rescue => e
+        json_ui.emit("error", message: e.message)
+      ensure
+        json_ui.set_idle_status
+      end
+
       # Run agent with UI2 split-screen interface
-      def run_agent_with_ui2(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil, is_session_load: false)
+      def run_agent_with_ui2(agent, working_dir, agent_config, session_manager = nil, client = nil, is_session_load: false)
         # Validate theme
         theme_name = options[:theme] || "hacker"
         available_themes = UI2::ThemeManager.available_themes.map(&:to_s)
@@ -315,7 +436,7 @@ module Clacky
         ui_controller = UI2::UIController.new(
           working_dir: working_dir,
           mode: agent_config.permission_mode.to_s,
-          model: agent_config.model,
+          model: agent_config.model_name,
           theme: theme_name
         )
 
@@ -325,17 +446,24 @@ module Clacky
         # Set skill loader for command suggestions
         ui_controller.set_skill_loader(agent.skill_loader)
 
-        # Track agent thread state
-        agent_thread = nil
+        # Track current working thread (agent or idle compression that can be interrupted)
+        # idle_timer is tracked separately because it should not be interrupted during sleep
+        current_task_thread = nil
+        idle_timer_thread = nil
 
         # Set up mode toggle handler
         ui_controller.on_mode_toggle do |new_mode|
           agent_config.permission_mode = new_mode.to_sym
         end
 
+        # Set up time machine handler (ESC key)
+        ui_controller.on_time_machine do
+          handle_time_machine_command(ui_controller, agent, session_manager)
+        end
+
         # Set up interrupt handler
         ui_controller.on_interrupt do |input_was_empty:|
-          if (not agent_thread&.alive?) && input_was_empty
+          if (not current_task_thread&.alive?) && input_was_empty
             # Save final session state before exit
             if session_manager && agent.total_tasks > 0
               session_data = agent.to_session_data(status: :exited)
@@ -360,21 +488,27 @@ module Clacky
             exit(0)
           end
 
-          if agent_thread&.alive?
-            agent_thread.raise(Clacky::AgentInterrupted, "User interrupted")
+          if current_task_thread&.alive?
+            current_task_thread.raise(Clacky::AgentInterrupted, "User interrupted")
           end
-          ui_controller.input_area.clear
-          ui_controller.input_area.set_tips("Press Ctrl+C again to exit.", type: :info)
+          ui_controller.clear_input
+          ui_controller.set_input_tips("Press Ctrl+C again to exit.", type: :info)
         end
 
         # Set up input handler
-        ui_controller.on_input do |input, images|
+        ui_controller.on_input do |input, images, display: nil|
           # Handle commands
           case input.downcase.strip
           when "/config"
-            handle_config_command(ui_controller, client, agent_config)
+            handle_config_command(ui_controller, client, agent_config, agent)
+            next
+          when "/undo"
+            handle_time_machine_command(ui_controller, agent, session_manager)
             next
           when "/clear"
+            sleep 0.1
+            # Clear output area
+            ui_controller.layout.clear_output
             # Clear session by creating a new agent
             agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller)
             ui_controller.show_info("Session cleared. Starting fresh.")
@@ -387,18 +521,75 @@ module Clacky
             ui_controller.stop
             exit(0)
           when "/help"
+            sleep 0.1
             ui_controller.show_help
             next
           end
 
-          # If agent is already running, interrupt it first
-          if agent_thread&.alive?
-            agent_thread.raise(Clacky::AgentInterrupted, "New input received")
-            agent_thread.join(2) # Wait up to 2 seconds for graceful shutdown
+          # If any task thread is running, interrupt it first
+          if current_task_thread&.alive?
+            current_task_thread.raise(Clacky::AgentInterrupted, "New input received")
+            current_task_thread.join(2) # Wait up to 2 seconds for graceful shutdown
+            ui_controller.set_idle_status
+          end
+
+          # Cancel idle timer if running (new input means user is active)
+          if idle_timer_thread&.alive?
+              ui_controller.log("Idle timer killed, start new 1", level: :debug)
+            idle_timer_thread.kill
+            idle_timer_thread = nil
+          end
+
+          # Helper method to start idle timer after agent completes
+          start_idle_timer = lambda do
+            # Cancel any existing idle timer first
+            if idle_timer_thread&.alive?
+              ui_controller.log("Idle timer killed, start new 2", level: :debug)
+              idle_timer_thread.kill
+              idle_timer_thread = nil
+            end
+
+            # Start idle timer - trigger compression after 180 seconds of inactivity
+            idle_timer_thread = Thread.new do
+              ui_controller.log("Idle timer started, will trigger compression in 180 seconds", level: :debug)
+              # Sleep outside of rescue block - if interrupted here, let it propagate and exit
+              sleep 180
+              ui_controller.log("Idle timer sleep completed, starting compression", level: :debug)
+
+              # After sleep completes, switch to current_task_thread for compression
+              # (so it can be interrupted by Ctrl+C)
+              current_task_thread = Thread.new do
+                begin
+                  # After 60 seconds, start idle compression
+                  ui_controller.set_working_status
+                  success = agent.trigger_idle_compression
+
+                  if success
+                    # Update session bar after compression
+                    ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+                    # Save session after compression
+                    session_manager&.save(agent.to_session_data(status: :success))
+                  end
+                rescue Clacky::AgentInterrupted
+                  # Compression was interrupted by user
+                  ui_controller.append_output("")
+                  ui_controller.show_info("Idle compression cancelled")
+                rescue => e
+                  ui_controller.log("Idle compression error: #{e.message}", level: :error)
+                ensure
+                  ui_controller.set_idle_status
+                  current_task_thread = nil
+                end
+              end
+
+              # Wait for compression to complete
+              current_task_thread.join
+              idle_timer_thread = nil
+            end
           end
 
           # Run agent in background thread
-          agent_thread = Thread.new do
+          current_task_thread = Thread.new do
             begin
               # Set status to working when agent starts
               ui_controller.set_working_status
@@ -417,7 +608,9 @@ module Clacky
             rescue Clacky::AgentInterrupted, StandardError => e
               handle_agent_exception(ui_controller, agent, session_manager, e)
             ensure
-              agent_thread = nil
+              current_task_thread = nil
+              # Start idle timer after agent completes
+              start_idle_timer.call
             end
           end
         end
@@ -432,36 +625,20 @@ module Clacky
           ui_controller.initialize_and_show_banner
         end
 
-        # If there's an initial message, process it
-        if initial_message && !initial_message.strip.empty?
-          ui_controller.show_user_message(initial_message)
-
-          begin
-            # Set status to working when agent starts
-            ui_controller.set_working_status
-
-            result = agent.run(initial_message, images: [])
-
-            if session_manager
-              session_manager.save(agent.to_session_data(status: :success))
-            end
-
-            # Update session bar with agent's cumulative stats
-            ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
-          rescue Clacky::AgentInterrupted, StandardError => e
-            handle_agent_exception(ui_controller, agent, session_manager, e)
-          end
-        end
-
         # Start input loop (blocks until exit)
         ui_controller.start_input_loop
 
+        # Cleanup: kill any running thread
+        current_task_thread&.kill
+
         # Save final session state
         if session_manager && agent.total_tasks > 0
           session_manager.save(agent.to_session_data)
         end
       end
 
+
+
     end
   end
 end

data/lib/clacky/client.rb

@@ -54,7 +54,11 @@ module Clacky
         end
         handle_test_response(response)
       end
+    rescue Faraday::Error => e
+      # Network or connection errors
+      { success: false, error: "Connection error: #{e.message}" }
     rescue => e
+      # Other errors
       { success: false, error: e.message }
     end
 
@@ -752,6 +756,11 @@ module Clacky
 
     # Extract the most meaningful error message from API response
     private def extract_error_message(error_body, raw_body)
+      # Check if response is HTML (indicates wrong endpoint or server error)
+      if raw_body.is_a?(String) && raw_body.strip.start_with?('<!DOCTYPE', '<html')
+        return "Invalid API endpoint or server error (received HTML instead of JSON)"
+      end
+
       return raw_body unless error_body.is_a?(Hash)
 
       # Priority order for error messages:
@@ -759,7 +768,7 @@ module Clacky
       # 2. error.message (Anthropic format)
       # 3. message
       # 4. error (string)
-      # 5. raw body
+      # 5. raw body (truncated if too long)
       if error_body["upstreamMessage"] && !error_body["upstreamMessage"].empty?
         error_body["upstreamMessage"]
       elsif error_body.dig("error", "message")
@@ -769,7 +778,8 @@ module Clacky
       elsif error_body["error"].is_a?(String)
         error_body["error"]
       else
-        raw_body
+        # Truncate raw body if too long
+        raw_body.is_a?(String) && raw_body.length > 200 ? "#{raw_body[0..200]}..." : raw_body
       end
     end
 

data/lib/clacky/default_skills/code-explorer/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: code-explorer
+description: Use this skill when exploring, analyzing, or understanding project/code structure. Required for tasks like "analyze project", "explore codebase", "understand how X works".
+fork_agent: true
+forbidden_tools:
+  - write
+  - edit
+auto_summarize: true
+---
+
+# Code Explorer Subagent
+
+You are now running in a **forked subagent** mode optimized for fast code exploration.
+
+## Your Mission
+Quickly explore and analyze the codebase to answer questions or gather information.
+
+## Your Restrictions
+- NO modifications: You CANNOT use `write` or `edit` tools
+- Read-only: Your role is to ANALYZE, not to change
+
+## Workflow — follow this order strictly
+
+1. **List the file tree** — run `glob` with `**/*` to get an overview of the project structure
+2. **Read README.md** — if it exists, read it to understand the project purpose and layout
+3. **Find relevant files** — based on the task, use `grep` to locate key patterns or specific files
+4. **Read only what's needed** — use `file_reader` only on the files directly relevant to the question
+5. **Report clearly** — provide a concise, actionable summary
+
+## Rules
+- Do NOT read files blindly — always have a reason before opening a file
+- Do NOT read every file in a directory — be selective
+- Prefer `grep` over `file_reader` for finding specific patterns
+- Stop as soon as you have enough information to answer the question

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

@@ -0,0 +1,13 @@
+---
+name: deploy
+description: Deploy Rails applications to Railway PaaS
+fork_agent: true
+---
+
+# Railway Deployment for Rails
+
+Deploy a Rails application to Railway platform.
+
+Execute the Rails deployment script located in this skill's `scripts/rails_deploy.rb`.
+
+The script validates the environment and runs an 8-step deployment workflow.