pocketrb 0.1.0

data/lib/pocketrb/tools/list_dir.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # List directory contents
+    class ListDir < Base
+      def name
+        "list_dir"
+      end
+
+      def description
+        "List the contents of a directory. Shows files and subdirectories with basic metadata."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path to the directory to list (defaults to workspace root)"
+            },
+            pattern: {
+              type: "string",
+              description: "Glob pattern to filter results (e.g., '*.rb', '**/*.ts')"
+            },
+            recursive: {
+              type: "boolean",
+              description: "List subdirectories recursively (default: false)"
+            },
+            include_hidden: {
+              type: "boolean",
+              description: "Include hidden files (starting with .) (default: false)"
+            }
+          },
+          required: []
+        }
+      end
+
+      def execute(path: nil, pattern: nil, recursive: false, include_hidden: false)
+        resolved = path ? validate_path!(path) : workspace
+
+        return error("Not a directory: #{path || "workspace"}") unless resolved&.directory?
+
+        entries = if pattern
+                    glob_pattern = resolved.join(recursive ? "**" : "", pattern)
+                    Dir.glob(glob_pattern)
+                  elsif recursive
+                    Dir.glob(resolved.join("**", "*"))
+                  else
+                    Dir.children(resolved).map { |e| resolved.join(e).to_s }
+                  end
+
+        # Filter hidden files
+        entries = entries.reject { |e| File.basename(e).start_with?(".") } unless include_hidden
+
+        # Sort entries
+        entries.sort!
+
+        # Format output
+        output = entries.map do |entry|
+          path_obj = Pathname.new(entry)
+          relative = workspace ? path_obj.relative_path_from(workspace) : path_obj
+          format_entry(path_obj, relative)
+        end
+
+        if output.empty?
+          "Directory is empty or no matches found"
+        else
+          output.join("\n")
+        end
+      end
+
+      private
+
+      def format_entry(path, relative)
+        if path.directory?
+          "#{relative}/"
+        else
+          size = format_size(path.size)
+          mtime = path.mtime.strftime("%Y-%m-%d %H:%M")
+          "#{relative} (#{size}, #{mtime})"
+        end
+      rescue StandardError
+        relative.to_s
+      end
+
+      def format_size(bytes)
+        units = %w[B KB MB GB]
+        unit_index = 0
+
+        size = bytes.to_f
+        while size >= 1024 && unit_index < units.length - 1
+          size /= 1024
+          unit_index += 1
+        end
+
+        format("%.1f%s", size, units[unit_index])
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/memory.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Simple memory tool - store and recall facts
+    class Memory < Base
+      ACTIONS = %w[store recall search recent stats].freeze
+      CATEGORIES = %w[learned user preference context].freeze
+
+      def name
+        "memory"
+      end
+
+      def description
+        <<~DESC.strip
+          Store and recall memories. Use this to remember important facts, preferences, and learnings.
+
+          Actions:
+          - store: Save a fact (categories: learned, user, preference, context)
+          - recall: Search for memories matching a query
+          - search: Deep search across all memory categories
+          - recent: Show recent events
+          - stats: Memory statistics
+        DESC
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ACTIONS,
+              description: "Memory action to perform"
+            },
+            category: {
+              type: "string",
+              enum: CATEGORIES,
+              description: "Category for storing (learned, user, preference, context)"
+            },
+            key: {
+              type: "string",
+              description: "Key/topic for the memory"
+            },
+            value: {
+              type: "string",
+              description: "Value/content to store"
+            },
+            query: {
+              type: "string",
+              description: "Search query for recall/search actions"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def available?
+        !memory_instance.nil?
+      end
+
+      def execute(action:, category: nil, key: nil, value: nil, query: nil, **)
+        return error("Memory not initialized") unless memory_instance
+
+        case action
+        when "store"
+          store_memory(category, key, value)
+        when "recall"
+          recall_memory(query)
+        when "search"
+          search_memory(query)
+        when "recent"
+          show_recent
+        when "stats"
+          show_stats
+        else
+          error("Unknown action: #{action}")
+        end
+      rescue StandardError => e
+        error("Memory error: #{e.message}")
+      end
+
+      private
+
+      def memory_instance
+        @context[:memory]
+      end
+
+      def store_memory(category, key, value)
+        return error("Category, key, and value required") unless category && key && value
+
+        result = case category
+                 when "learned"
+                   memory_instance.remember_learned(key, value)
+                 when "user"
+                   memory_instance.remember_user(key, value)
+                 when "preference"
+                   memory_instance.remember_preference(key, value)
+                 when "context"
+                   memory_instance.remember_context(key, value)
+                 else
+                   return error("Invalid category. Use: learned, user, preference, or context")
+                 end
+
+        success(result)
+      end
+
+      def recall_memory(query)
+        return error("Query required") unless query
+
+        context = memory_instance.relevant_context(query, max_facts: 10)
+
+        if context.empty?
+          "No relevant memories found for: #{query}"
+        else
+          "Relevant memories:\n\n#{context}"
+        end
+      end
+
+      def search_memory(query)
+        return error("Query required") unless query
+
+        results = memory_instance.search(query)
+
+        return "No memories found matching: #{query}" if results.empty?
+
+        lines = ["Found #{results.size} memories:"]
+        results.each_with_index do |result, i|
+          lines << "\n#{i + 1}. [#{result[:type]}] #{result[:topic] || result[:key]}"
+          lines << "   #{result[:content] || result[:value]}"
+          lines << "   (#{result[:date]})" if result[:date]
+        end
+
+        lines.join("\n")
+      end
+
+      def show_recent
+        events = memory_instance.recent_events(10)
+
+        return "No recent events recorded." if events.empty?
+
+        lines = ["Recent events (#{events.size}):"]
+        events.each do |event|
+          timestamp = Time.parse(event["timestamp"]).strftime("%Y-%m-%d %H:%M")
+          lines << "- [#{timestamp}] #{event["description"]}"
+        end
+
+        lines.join("\n")
+      end
+
+      def show_stats
+        stats = memory_instance.stats
+
+        lines = [
+          "Memory Statistics:",
+          "- Learned topics: #{stats[:learned_topics]} (#{stats[:total_learned]} total facts)",
+          "- User facts: #{stats[:user_facts]}",
+          "- Preferences: #{stats[:preferences]}",
+          "- Context items: #{stats[:context_items]}",
+          "- Recent events: #{stats[:recent_events]}"
+        ]
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/message.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Tool for sending messages to chat channels programmatically
+    class Message < Base
+      def name
+        "message"
+      end
+
+      def description
+        "Send a message to a chat channel. Use this to proactively communicate with users, send notifications, or respond on specific channels."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "The message content to send"
+            },
+            channel: {
+              type: "string",
+              description: "Target channel (telegram, whatsapp, cli). Uses default if not specified."
+            },
+            chat_id: {
+              type: "string",
+              description: "Recipient chat ID. Uses default if not specified."
+            }
+          },
+          required: ["content"]
+        }
+      end
+
+      def execute(content:, channel: nil, chat_id: nil)
+        # Use defaults from context if not provided
+        channel = (channel || @context[:default_channel])&.to_sym
+        chat_id ||= @context[:default_chat_id]
+
+        return error("No channel specified and no default channel in context") unless channel
+
+        return error("No chat_id specified and no default chat_id in context") unless chat_id
+
+        return error("Message bus not available in context") unless bus
+
+        outbound = Bus::OutboundMessage.new(
+          channel: channel,
+          chat_id: chat_id,
+          content: content
+        )
+
+        bus.publish_outbound(outbound)
+        Pocketrb.logger.info("Message sent to #{channel}:#{chat_id}")
+
+        success("Message sent to #{channel}:#{chat_id}")
+      end
+
+      def available?
+        !bus.nil?
+      end
+
+      private
+
+      def bus
+        @context[:bus]
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/para_memory.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # PARA-based memory tool for structured knowledge management
+    class ParaMemory < Base
+      def name
+        "para_memory"
+      end
+
+      def description
+        <<~DESC.strip
+          Structured memory using PARA method. Store and retrieve facts about people, projects,
+          companies, and topics. Facts are organized, decay over time, and build a knowledge graph.
+          Use this for durable information that should persist across conversations.
+        DESC
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: %w[store search entity_info create_entity list_entities context preferences learn_preference],
+              description: "Action to perform"
+            },
+            # For store action
+            content: {
+              type: "string",
+              description: "Fact content to store"
+            },
+            category: {
+              type: "string",
+              enum: %w[relationship milestone status preference context],
+              description: "Fact category (for store)"
+            },
+            entity_type: {
+              type: "string",
+              enum: %w[projects areas resources archives],
+              description: "PARA entity type"
+            },
+            entity_name: {
+              type: "string",
+              description: "Entity name (e.g., 'zakiya', 'people/john', 'companies/acme')"
+            },
+            # For search action
+            query: {
+              type: "string",
+              description: "Search query"
+            },
+            # For create_entity
+            entity_subtype: {
+              type: "string",
+              enum: %w[project person company topic],
+              description: "What kind of entity to create"
+            },
+            # For learn_preference
+            preference_category: {
+              type: "string",
+              enum: %w[communication_preferences working_style tool_preferences rules_and_boundaries],
+              description: "Preference category"
+            },
+            preference_key: {
+              type: "string",
+              description: "Preference key (e.g., 'verbosity', 'timezone')"
+            },
+            preference_value: {
+              type: "string",
+              description: "Preference value"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def available?
+        !para_manager.nil?
+      end
+
+      def execute(action:, **args)
+        return error("PARA memory not available. Configure memory_dir in agent settings.") unless para_manager
+
+        case action
+        when "store"
+          store_fact(args)
+        when "search"
+          search_memory(args[:query])
+        when "entity_info"
+          get_entity_info(args[:entity_type], args[:entity_name])
+        when "create_entity"
+          create_entity(args)
+        when "list_entities"
+          list_entities(args[:entity_type])
+        when "context"
+          get_context(args[:query])
+        when "preferences"
+          get_preferences
+        when "learn_preference"
+          learn_preference(args)
+        else
+          error("Unknown action: #{action}")
+        end
+      end
+
+      private
+
+      def para_manager
+        @context[:para_manager]
+      end
+
+      def store_fact(args)
+        content = args[:content]
+        return error("Content required") if content.nil? || content.empty?
+
+        category = (args[:category] || "context").to_sym
+        entity_type = args[:entity_type]&.to_sym
+        entity_name = args[:entity_name]
+
+        if entity_type && entity_name
+          fact = para_manager.store_fact(
+            entity_type: entity_type,
+            entity_name: entity_name,
+            content: content,
+            category: category
+          )
+          success("Stored fact in #{entity_type}/#{entity_name}: #{content[0..50]}... (ID: #{fact.id})")
+        else
+          para_manager.remember(content: content, category: category)
+          success("Stored fact: #{content[0..50]}...")
+        end
+      end
+
+      def search_memory(query)
+        return error("Query required") if query.nil? || query.empty?
+
+        results = para_manager.search(query)
+
+        lines = ["Search results for: #{query}\n"]
+
+        if results[:knowledge_graph].any?
+          lines << "**Knowledge Graph:**"
+          results[:knowledge_graph].each do |r|
+            lines << "  #{r[:entity]}:"
+            r[:facts].first(3).each { |f| lines << "    - #{f}" }
+          end
+        end
+
+        if results[:daily_notes].any?
+          lines << "\n**Daily Notes:**"
+          results[:daily_notes].first(5).each do |r|
+            lines << "  #{r[:date]}:"
+            r[:matches].first(2).each { |m| lines << "    - #{m}" }
+          end
+        end
+
+        if results[:tacit].any?
+          lines << "\n**Preferences:**"
+          results[:tacit].each do |r|
+            lines << "  #{r[:category]}/#{r[:key]}: #{r[:value]}"
+          end
+        end
+
+        lines << "No results found." if lines.size == 1
+
+        lines.join("\n")
+      end
+
+      def get_entity_info(entity_type, entity_name)
+        return error("Entity type and name required") unless entity_type && entity_name
+
+        summary = para_manager.entity_summary(type: entity_type.to_sym, name: entity_name)
+        return error("Entity not found: #{entity_type}/#{entity_name}") unless summary
+
+        summary
+      end
+
+      def create_entity(args)
+        subtype = args[:entity_subtype]
+        name = args[:entity_name]
+        content = args[:content]
+
+        return error("Entity subtype and name required") unless subtype && name
+
+        case subtype
+        when "project"
+          para_manager.create_project(name: name, description: content)
+          success("Created project: #{name}")
+        when "person"
+          para_manager.create_person(name: name, relationship: content)
+          success("Created person: #{name}")
+        when "company"
+          para_manager.create_company(name: name, context: content)
+          success("Created company: #{name}")
+        when "topic"
+          para_manager.knowledge_graph.create_entity(
+            type: :resources,
+            name: name,
+            initial_facts: content ? [{ content: content, category: :context }] : []
+          )
+          success("Created topic: #{name}")
+        else
+          error("Unknown entity subtype: #{subtype}")
+        end
+      end
+
+      def list_entities(entity_type)
+        if entity_type
+          entities = para_manager.knowledge_graph.list_entities(entity_type.to_sym)
+          return "No #{entity_type} entities found." if entities.empty?
+
+          lines = ["#{entity_type.capitalize}:"]
+          entities.each do |e|
+            e.load!
+            lines << "  - #{e.name} (#{e.active_facts.size} facts)"
+          end
+          lines.join("\n")
+        else
+          para_manager.full_context_summary
+        end
+      end
+
+      def get_context(query)
+        if query && !query.empty?
+          para_manager.relevant_context(query)
+        else
+          para_manager.full_context_summary
+        end
+      end
+
+      def get_preferences
+        prefs = para_manager.get_preferences
+        return "No learned preferences yet." if prefs.empty?
+
+        lines = ["User Preferences:"]
+        prefs.each do |category, items|
+          lines << "\n#{category.to_s.tr("_", " ").capitalize}:"
+          items.each do |key, pref|
+            conf = (pref[:confidence] * 100).to_i
+            lines << "  - #{key}: #{pref[:value]} (#{conf}% confident)"
+          end
+        end
+        lines.join("\n")
+      end
+
+      def learn_preference(args)
+        category = args[:preference_category]
+        key = args[:preference_key]
+        value = args[:preference_value]
+
+        return error("Category, key, and value required") unless category && key && value
+
+        para_manager.learn_preference(
+          category: category.to_sym,
+          key: key.to_sym,
+          value: value,
+          source: "conversation"
+        )
+
+        success("Learned preference: #{key} = #{value}")
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/read_file.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Read file contents
+    class ReadFile < Base
+      def name
+        "read_file"
+      end
+
+      def description
+        "Read the contents of a file. Returns the file content as text."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path to the file to read (relative to workspace or absolute)"
+            },
+            offset: {
+              type: "integer",
+              description: "Line number to start reading from (1-indexed, optional)"
+            },
+            limit: {
+              type: "integer",
+              description: "Maximum number of lines to read (optional)"
+            }
+          },
+          required: ["path"]
+        }
+      end
+
+      def execute(path:, offset: nil, limit: nil)
+        resolved = validate_path!(path)
+
+        return error("Not a file: #{path}") unless resolved.file?
+
+        content = File.read(resolved)
+        lines = content.lines
+
+        # Apply offset and limit
+        lines = lines[(offset - 1)..] if offset && offset > 1
+
+        lines = lines.first(limit) if limit
+
+        # Add line numbers
+        start_line = offset || 1
+        numbered_lines = lines.each_with_index.map do |line, idx|
+          "#{start_line + idx}: #{line}"
+        end
+
+        numbered_lines.join
+      rescue Errno::ENOENT
+        error("File not found: #{path}")
+      rescue Errno::EACCES
+        error("Permission denied: #{path}")
+      rescue Errno::EISDIR
+        error("Is a directory: #{path}")
+      end
+    end
+  end
+end