openclacky 0.9.7 → 0.9.9

data/lib/clacky/server/session_registry.rb

@@ -2,38 +2,45 @@
 
 module Clacky
   module Server
-    # SessionRegistry manages runtime state for active Agent sessions in the web server.
-    # Each entry holds the Agent instance plus web-server-specific runtime fields that
-    # the Agent itself doesn't own: status, error, execution thread, UI controller, and
-    # transient scheduling fields (pending_task / pending_working_dir).
+    # SessionRegistry is the single authoritative source for session state.
     #
-    # Fields that already live on the Agent (name, created_at, working_dir, total_tasks,
-    # total_cost) are read directly from the agent — the registry never duplicates them.
+    # It owns two concerns:
+    #   1. Runtime state  — agent instance, thread, status, pending_task, idle_timer.
+    #   2. Session list   — reads from disk (via session_manager) and enriches with
+    #                       live runtime status. `list` is the only place the session
+    #                       list is assembled; no callers should build it elsewhere.
+    #
+    # Lazy restore: `ensure(session_id)` loads a disk session into the registry on
+    # demand. All session-specific APIs call this before touching the registry so
+    # disk-only sessions (e.g. loaded via loadMore) just work transparently.
     #
     # Thread safety: all public methods are protected by a Mutex.
     class SessionRegistry
       SESSION_TIMEOUT = 24 * 60 * 60 # 24 hours of inactivity before cleanup
 
-      def initialize
-        @sessions = {}
-        @mutex    = Mutex.new
+      # session_manager: Clacky::SessionManager instance
+      # session_restorer: callable(session_data) → session_id — builds agent + wires into registry
+      def initialize(session_manager: nil, session_restorer: nil)
+        @sessions         = {}
+        @mutex            = Mutex.new
+        @session_manager  = session_manager
+        @session_restorer = session_restorer
       end
 
-      # Create a new session entry and return its id.
-      # session_id must come from the caller (use SessionManager.generate_id).
+      # Create a new (empty) session entry and return its id.
       # agent/ui/thread are set later via with_session once they are constructed.
       def create(session_id:)
         raise ArgumentError, "session_id is required" if session_id.nil? || session_id.empty?
 
         session = {
           id:                   session_id,
-          status:               :idle,   # :idle | :running | :error
+          status:               :idle,
           error:                nil,
           updated_at:           Time.now,
           agent:                nil,
           ui:                   nil,
           thread:               nil,
-          idle_timer:           nil,     # IdleCompressionTimer instance
+          idle_timer:           nil,
           pending_task:         nil,
           pending_working_dir:  nil
         }
@@ -42,13 +49,45 @@ module Clacky
         session_id
       end
 
+      # Ensure a session is in the registry, loading from disk if necessary.
+      # Returns true if the session is now available, false if not found anywhere.
+      def ensure(session_id)
+        return true if exist?(session_id)
+        return false unless @session_manager && @session_restorer
+
+        session_data = @session_manager.load(session_id)
+        return false unless session_data
+
+        @session_restorer.call(session_data)
+        exist?(session_id)
+      end
+
+      # Restore all sessions from disk (up to n per source type) into the registry.
+      # Used at startup. Already-registered sessions are skipped.
+      def restore_from_disk(n: 5)
+        return unless @session_manager && @session_restorer
+
+        all = @session_manager.all_sessions
+          .sort_by { |s| s[:created_at] || "" }
+          .reverse
+
+        # Take up to n per source type
+        counts = Hash.new(0)
+        all.each do |session_data|
+          src = (session_data[:source] || "manual").to_s
+          next if counts[src] >= n
+          next if exist?(session_data[:session_id])
+          @session_restorer.call(session_data)
+          counts[src] += 1
+        end
+      end
+
       # Retrieve a session hash by id (returns nil if not found).
       def get(session_id)
         @mutex.synchronize { @sessions[session_id]&.dup }
       end
 
       # Update arbitrary runtime fields of a session (status, error, pending_*, etc.).
-      # Always stamps updated_at.
       def update(session_id, **fields)
         @mutex.synchronize do
           session = @sessions[session_id]
@@ -60,18 +99,68 @@ module Clacky
         end
       end
 
-      # Return a lightweight summary list (no agent/ui/thread objects) for API responses.
-      # Sorted newest-first using agent.created_at (ISO8601 strings sort lexicographically).
-      def list
-        @mutex.synchronize do
-          @sessions.values
-                   .map { |s| session_summary(s) }
-                   .sort_by { |s| s[:created_at] }
-                   .reverse
+      # Return a session list from disk enriched with live registry status.
+      # Sorted by created_at descending (newest first).
+      #
+      # Parameters (all optional, independent):
+      #   source:  "manual"|"cron"|"channel"|"setup"|nil
+      #            nil = no source filter (all sessions)
+      #   profile: "general"|"coding"|nil
+      #            nil = no agent_profile filter
+      #   limit:   max sessions to return
+      #   before:  ISO8601 cursor — only sessions with created_at < before
+      #
+      # source and profile are orthogonal — either can be nil independently.
+      def list(limit: nil, before: nil, source: nil, profile: nil)
+        return [] unless @session_manager
+
+        live = @mutex.synchronize do
+          @sessions.transform_values { |s| { status: s[:status], error: s[:error] } }
+        end
+
+        all = @session_manager.all_sessions  # already sorted newest-first
+
+        # ── source filter ────────────────────────────────────────────────────
+        all = all.select { |s| s_source(s) == source } if source
+        # source == nil → no filter, return all
+
+        # ── profile filter ───────────────────────────────────────────────────
+        all = all.select { |s| (s[:agent_profile] || "general").to_s == profile } if profile
+
+        all = all.select { |s| (s[:created_at] || "") < before } if before
+        all = all.first(limit) if limit
+
+        all.map do |s|
+          id = s[:session_id]
+          ls = live[id]
+          {
+            id:            id,
+            name:          s[:name] || "",
+            status:        ls ? ls[:status].to_s : "idle",
+            error:         ls ? ls[:error] : nil,
+            source:        s_source(s),
+            agent_profile: (s[:agent_profile] || "general").to_s,
+            working_dir:   s[:working_dir],
+            created_at:    s[:created_at],
+            updated_at:    s[:updated_at],
+            total_tasks:   s.dig(:stats, :total_tasks) || 0,
+            total_cost:    s.dig(:stats, :total_cost_usd) || 0.0,
+          }
         end
       end
 
-      # Delete a session. Also interrupts any running agent thread.
+      private
+
+      # Normalize source field from a disk session hash.
+      # "system" is a legacy value renamed to "setup" — treat them as equivalent.
+      def s_source(s)
+        src = (s[:source] || "manual").to_s
+        src == "system" ? "setup" : src
+      end
+
+      public
+
+      # Delete a session from registry (and interrupt its thread).
       def delete(session_id)
         @mutex.synchronize do
           session = @sessions.delete(session_id)
@@ -83,23 +172,21 @@ module Clacky
         end
       end
 
-      # True if the session exists.
+      # True if the session exists in registry (runtime).
       def exist?(session_id)
         @mutex.synchronize { @sessions.key?(session_id) }
       end
 
       # Execute a block with exclusive access to the raw session hash.
-      # Use this to set agent/ui/thread references that must not be dup'd.
       def with_session(session_id)
         @mutex.synchronize do
           session = @sessions[session_id]
           return nil unless session
-
           yield session
         end
       end
 
-      # Remove sessions that have been idle longer than SESSION_TIMEOUT.
+      # Remove sessions idle longer than SESSION_TIMEOUT.
       def cleanup_stale!
         cutoff = Time.now - SESSION_TIMEOUT
         @mutex.synchronize do
@@ -109,25 +196,29 @@ module Clacky
         end
       end
 
-      private
+      # Build a summary hash for API responses (for in-registry sessions).
+      # Used when we need live agent fields (name, cost, etc.) after ensure().
+      def session_summary(session_id)
+        session = @mutex.synchronize { @sessions[session_id] }
+        return nil unless session
+        agent = session[:agent]
+        return nil unless agent
 
-      # Build a summary hash for API responses, reading authoritative fields from the
-      # agent and runtime-only fields from the registry entry.
-      def session_summary(session)
-        agent      = session[:agent]
-        model_info = agent&.current_model_info
+        model_info = agent.current_model_info
         {
           id:              session[:id],
-          name:            agent&.name        || "",
-          working_dir:     agent&.working_dir || "",
+          name:            agent.name,
+          working_dir:     agent.working_dir,
           status:          session[:status],
-          created_at:      agent&.created_at  || session[:updated_at].iso8601,
+          created_at:      agent.created_at,
           updated_at:      session[:updated_at].iso8601,
-          total_tasks:     agent&.total_tasks || 0,
-          total_cost:      agent&.total_cost  || 0.0,
+          total_tasks:     agent.total_tasks || 0,
+          total_cost:      agent.total_cost  || 0.0,
           error:           session[:error],
-          model:           model_info&.dig(:model) || "",
-          permission_mode: agent&.permission_mode || ""
+          model:           model_info&.dig(:model),
+          permission_mode: agent.permission_mode,
+          source:          agent.source.to_s,
+          agent_profile:   agent.agent_profile.name,
         }
       end
     end

data/lib/clacky/server/web_ui_controller.rb

@@ -65,11 +65,23 @@ module Clacky
 
       # === Output display ===
 
-      def show_user_message(content, created_at: nil, images: [])
+      def show_user_message(content, created_at: nil, files: [], source: :web)
         data = { content: content }
         data[:created_at] = created_at if created_at
-        data[:images]     = images if images && !images.empty?
+        # Build ev.images for the frontend renderer (history_user_message):
+        #   - Images with data_url → pass the data_url directly (<img> thumbnail)
+        #   - Disk files (PDF, doc, etc., no data_url) → "pdf:name" sentinel (renders a badge)
+        rendered = Array(files).filter_map do |f|
+          url  = f[:data_url] || f["data_url"]
+          name = f[:name]     || f["name"]
+          url || (name ? "pdf:#{name}" : nil)
+        end
+        data[:images] = rendered unless rendered.empty?
         emit("history_user_message", **data)
+        # Only forward to channel subscribers when the message originated from the WebUI,
+        # to avoid echoing channel messages back to the same channel.
+        return unless source == :web
+        forward_to_subscribers { |sub| sub.show_user_message(content) if sub.respond_to?(:show_user_message) }
       end
 
       def show_assistant_message(content, files:)
@@ -161,6 +173,13 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_info(message) }
       end
 
+      # Emit a two-phase idle compression status update.
+      # The frontend uses the same DOM element for both phases so it renders as one line.
+      # phase: :start → show spinner message; phase: :end → update in-place with final result
+      def show_idle_status(phase:, message:)
+        emit("idle_status", phase: phase.to_s, message: message)
+      end
+
       def show_warning(message)
         emit("warning", message: message)
         forward_to_subscribers { |sub| sub.show_warning(message) }

data/lib/clacky/session_manager.rb

@@ -21,7 +21,7 @@ module Clacky
       ensure_sessions_dir
     end
 
-    # Save a session
+    # Save a session. Returns the file path.
     def save(session_data)
       filename = generate_filename(session_data[:session_id], session_data[:created_at])
       filepath = File.join(@sessions_dir, filename)
@@ -31,98 +31,81 @@ module Clacky
 
       @last_saved_path = filepath
 
-      # Keep only the most recent 10 sessions (best-effort, never block save)
+      # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
-        cleanup_by_count(keep: 10)
+        cleanup_by_count(keep: 200)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
-        # so that the session file is always saved successfully
       end
 
       filepath
     end
 
-    # Get the path of the last saved session
+    # Path of the last saved session file.
     def last_saved_path
       @last_saved_path
     end
 
-    # Load a specific session by ID
+    # Load a specific session by ID. Returns nil if not found.
     def load(session_id)
-      sessions = all_sessions
-      session = sessions.find { |s| s[:session_id].start_with?(session_id) }
-      session
+      all_sessions.find { |s| s[:session_id].to_s.start_with?(session_id.to_s) }
     end
 
-    # Get the most recent session for a specific working directory
-    def latest_for_directory(working_dir)
-      sessions = all_sessions
-      sessions
-        .select { |s| s[:working_dir] == working_dir }
-        .max_by { |s| Time.parse(s[:updated_at]) }
-    end
+    # Physical delete — removes disk file + associated chunk files.
+    # Returns true if found and deleted, false if not found.
+    def delete(session_id)
+      session = all_sessions.find { |s| s[:session_id].to_s.start_with?(session_id.to_s) }
+      return false unless session
 
-    # Get the most recent N sessions for a specific working directory
-    def latest_n_for_directory(working_dir, n = 5)
-      all_sessions
-        .select { |s| s[:working_dir] == working_dir }
-        .sort_by { |s| Time.parse(s[:updated_at]) }
-        .reverse
-        .first(n)
+      filepath = File.join(@sessions_dir, generate_filename(session[:session_id], session[:created_at]))
+      delete_session_with_chunks(filepath)
+      true
     end
 
-    # List recent sessions, prioritizing those from current directory
-    def list(current_dir: nil, limit: 5)
-      sessions = all_sessions.sort_by { |s| Time.parse(s[:updated_at]) }.reverse
+    # All sessions from disk, newest-first (sorted by created_at).
+    # Optional filters:
+    #   current_dir: (String) if given, sessions matching working_dir come first
+    #   limit:       (Integer) max number of sessions to return
+    def all_sessions(current_dir: nil, limit: nil)
+      sessions = Dir.glob(File.join(@sessions_dir, "*.json")).filter_map do |filepath|
+        load_session_file(filepath)
+      end.sort_by { |s| s[:created_at] || "" }.reverse
 
       if current_dir
         current_sessions = sessions.select { |s| s[:working_dir] == current_dir }
-        other_sessions = sessions.reject { |s| s[:working_dir] == current_dir }
-        (current_sessions + other_sessions).first(limit)
-      else
-        sessions.first(limit)
+        other_sessions   = sessions.reject { |s| s[:working_dir] == current_dir }
+        sessions = current_sessions + other_sessions
       end
-    end
 
-    # Delete old sessions (older than days)
-    def cleanup(days: 30)
-      cutoff_time = Time.now - (days * 24 * 60 * 60)
-      deleted_count = 0
+      limit ? sessions.first(limit) : sessions
+    end
 
+    # Delete sessions not accessed within the given number of days (default: 90).
+    # Returns count of deleted sessions.
+    def cleanup(days: 90)
+      cutoff = Time.now - (days * 24 * 60 * 60)
+      deleted = 0
       Dir.glob(File.join(@sessions_dir, "*.json")).each do |filepath|
         session = load_session_file(filepath)
         next unless session
-
-        updated_at = Time.parse(session[:updated_at])
-        if updated_at < cutoff_time
+        if Time.parse(session[:updated_at]) < cutoff
           delete_session_with_chunks(filepath)
-          deleted_count += 1
+          deleted += 1
         end
       end
-
-      deleted_count
+      deleted
     end
 
-    # Keep only the most recent N sessions, delete older ones
+    # Keep only the most recent N sessions by created_at; delete the rest.
+    # Returns count of deleted sessions.
     def cleanup_by_count(keep:)
-      sessions = all_sessions.sort_by { |s| Time.parse(s[:updated_at]) }.reverse
-
+      sessions = all_sessions # already sorted newest-first
       return 0 if sessions.size <= keep
 
-      sessions_to_delete = sessions[keep..]
-      deleted_count = 0
-
-      sessions_to_delete.each do |session|
-        filename = generate_filename(session[:session_id], session[:created_at])
-        filepath = File.join(@sessions_dir, filename)
-
-        if File.exist?(filepath)
-          delete_session_with_chunks(filepath)
-          deleted_count += 1
-        end
-      end
-
-      deleted_count
+      sessions[keep..].each do |session|
+        filepath = File.join(@sessions_dir, generate_filename(session[:session_id], session[:created_at]))
+        delete_session_with_chunks(filepath) if File.exist?(filepath)
+      end.size
     end
 
     private
@@ -137,24 +120,11 @@ module Clacky
       "#{datetime}-#{short_id}.json"
     end
 
-    # Delete a session JSON file and all its associated chunk MD files
-    # Chunk files follow the pattern: {base}-chunk-{n}.md
+    # Delete a session JSON file and all its associated chunk MD files.
     def delete_session_with_chunks(json_filepath)
-      # Delete the main session JSON
       File.delete(json_filepath) if File.exist?(json_filepath)
-
-      # Find and delete associated chunk MD files
       base = File.basename(json_filepath, ".json")
-      chunk_pattern = File.join(@sessions_dir, "#{base}-chunk-*.md")
-      Dir.glob(chunk_pattern).each do |chunk_file|
-        File.delete(chunk_file)
-      end
-    end
-
-    def all_sessions
-      Dir.glob(File.join(@sessions_dir, "*.json")).map do |filepath|
-        load_session_file(filepath)
-      end.compact
+      Dir.glob(File.join(@sessions_dir, "#{base}-chunk-*.md")).each { |f| File.delete(f) }
     end
 
     def load_session_file(filepath)

data/lib/clacky/skill.rb

@@ -2,6 +2,8 @@
 
 require "yaml"
 require "pathname"
+require_relative "utils/file_ignore_helper"
+require_relative "utils/gitignore_parser"
 
 module Clacky
   # Represents a skill with its metadata and content.
@@ -169,47 +171,97 @@ module Clacky
 
     # Get all supporting files in the skill directory (excluding SKILL.md)
     # @return [Array<Pathname>]
+    # Return plain-text supporting files for this skill (non-encrypted skills only).
+    # For encrypted skills this always returns [] — the decrypted files live in a
+    # tmpdir created by SkillManager at invoke time (see has_supporting_scripts?).
+    # @return [Array<Pathname>]
     def supporting_files
       return [] unless @directory.exist?
+      return [] if encrypted?
+
+      dir = @directory.to_s
+      gitignore_path = Utils::FileIgnoreHelper.find_gitignore(dir)
+      gitignore = gitignore_path ? GitignoreParser.new(gitignore_path) : nil
 
-      @directory.children.reject { |p| p.basename.to_s == "SKILL.md" }
+      Dir.glob(File.join(dir, "**", "*"))
+         .reject { |f| File.directory?(f) }
+         .reject { |f| File.basename(f) == "SKILL.md" }
+         .reject { |f| Utils::FileIgnoreHelper.should_ignore_file?(f, dir, gitignore) }
+         .map { |f| Pathname.new(f) }
+         .sort
     end
 
-    # Check if this skill has supporting files
+    # Check if this skill has any supporting files/scripts beyond SKILL.md.
+    # For encrypted skills, checks for .enc files that are not SKILL.md.enc or the manifest.
+    # For plain skills, checks for any files other than SKILL.md.
     # @return [Boolean]
     def has_supporting_files?
-      supporting_files.any?
+      return false unless @directory.exist?
+
+      if encrypted?
+        Dir.glob(File.join(@directory.to_s, "**", "*.enc")).any? do |f|
+          base = File.basename(f)
+          base != "SKILL.md.enc" && base != "MANIFEST.enc.json"
+        end
+      else
+        supporting_files.any?
+      end
     end
 
+
+
     # Process the skill content with argument substitution and template expansion
     # @param arguments [String] Arguments passed to the skill
     # @param shell_output [Hash] Shell command outputs for !command` syntax (optional)
     # @param template_context [Hash] Named values for <%= key %> template expansion (optional)
+    # @param script_dir [String, nil] When provided, the Supporting Files block uses this
+    #   directory instead of @directory. Used by SkillManager to point the LLM at the
+    #   tmpdir containing decrypted scripts for encrypted brand skills.
     # @return [String] Processed content
-    def process_content(arguments = "", shell_output: {}, template_context: {})
+    def process_content(shell_output: {}, template_context: {}, script_dir: nil)
       # For brand skills, decrypt content in memory at invoke time.
       # For plain skills, use the already-loaded @content.
       processed_content = decrypted_content.dup
 
-      # Expand <%= key %> templates before argument substitution
+      # Expand <%= key %> templates
       processed_content = expand_templates(processed_content, template_context)
 
-      # Replace argument placeholders
-      processed_content = substitute_arguments(processed_content, arguments)
-
       # Replace shell command outputs
       shell_output.each do |command, output|
         placeholder = "!`#{command}`"
         processed_content.gsub!(placeholder, output.to_s)
       end
 
-      # Append supporting files list if any exist
-      if has_supporting_files?
+      # Append supporting files list if any exist.
+      # When script_dir is given (encrypted skill with decrypted tmpdir), use that
+      # directory for both the path label and the file listing so the LLM sees real
+      # paths it can actually execute.
+      effective_dir = script_dir || @directory.to_s
+      effective_files = if script_dir && Dir.exist?(script_dir)
+        gitignore_path = Utils::FileIgnoreHelper.find_gitignore(script_dir)
+        gitignore = gitignore_path ? GitignoreParser.new(gitignore_path) : nil
+        Dir.glob(File.join(script_dir, "**", "*"))
+           .reject { |f| File.directory?(f) }
+           .reject { |f| Utils::FileIgnoreHelper.should_ignore_file?(f, script_dir, gitignore) }
+           .map { |f| f.sub("#{script_dir}/", "") }
+           .sort
+      else
+        supporting_files.map { |p| p.relative_path_from(@directory).to_s }
+      end
+
+      if effective_files.any?
+        max_files = 20
+        truncated = effective_files.length > max_files
+        listed_files = effective_files.first(max_files)
+
         processed_content += "\n\n## Supporting Files\n\n"
-        processed_content += "The following files are available in this skill's directory (`#{@directory}`):\n\n"
-        supporting_files.each do |file|
+        processed_content += "The following files are available in this skill's directory (`#{effective_dir}`):\n\n"
+        listed_files.each do |file|
           processed_content += "- `#{file}`\n"
         end
+        if truncated
+          processed_content += "\n_(#{effective_files.length - max_files} more files not shown)_\n"
+        end
       end
 
       processed_content
@@ -492,36 +544,6 @@ module Clacky
       content
     end
 
-    def substitute_arguments(content, arguments)
-      # Split arguments by whitespace for indexed access ($0, $1, $ARGUMENTS[N]).
-      # Skill arguments are natural language, not shell commands — shellsplit is
-      # intentionally avoided here to prevent errors on apostrophes and other
-      # characters that have special meaning in shell but not in plain text.
-      args_array = arguments.split
 
-      # Replace $SKILL_DIR with the absolute path of this skill's directory.
-      # Allows SKILL.md files to reference bundled scripts without runtime `find`.
-      result = content.gsub("$SKILL_DIR", @directory.to_s)
-
-      # Replace $ARGUMENTS with all arguments
-      result = result.gsub("$ARGUMENTS", arguments.to_s)
-
-      # Replace $ARGUMENTS[N] with specific argument
-      result.gsub!(/\$ARGUMENTS\[(\d+)\]/) do
-        index = $1.to_i
-        args_array[index] || ""
-      end
-
-      # Replace $N shorthand ($0, $1, etc.)
-      result.gsub!(/\$([0-9]+)/) do
-        index = $1.to_i
-        args_array[index] || ""
-      end
-
-      # Replace ${CLAUDE_SESSION_ID} with empty string (session not available in current context)
-      result.gsub!(/\${CLAUDE_SESSION_ID}/, "")
-
-      result
-    end
   end
 end