pocketrb 0.1.0

data/lib/pocketrb/memory.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Pocketrb
+  # Simple memory system for facts and recent events
+  # Inspired by nanobot - no vector DB, just JSON + keyword matching
+  class Memory
+    # Maximum number of recent events to keep
+    MAX_RECENT = 50
+
+    # Initialize memory system
+    # @param workspace [String, Pathname] workspace directory
+    def initialize(workspace:)
+      @workspace = Pathname.new(workspace)
+      @memory_dir = @workspace.join("memory")
+      @memory_dir.mkpath
+
+      @facts_file = @memory_dir.join("facts.json")
+      @recent_file = @memory_dir.join("recent.json")
+
+      @facts = load_json(@facts_file) || { "learned" => {}, "user" => {}, "preferences" => {}, "context" => {} }
+      @recent = load_json(@recent_file) || []
+    end
+
+    # === Long-term facts ===
+
+    # Remember something learned
+    # @param topic [String] topic name
+    # @param info [String] information about the topic
+    # @return [String] confirmation message
+    def remember_learned(topic, info)
+      @facts["learned"][topic] ||= []
+      @facts["learned"][topic] << {
+        "info" => info,
+        "learned_at" => Time.now.utc.iso8601
+      }
+      save_facts
+      "Remembered: learned about #{topic}"
+    end
+
+    # Remember user preference/info
+    # @param key [String] user attribute key
+    # @param value [String] user attribute value
+    # @return [String] confirmation message
+    def remember_user(key, value)
+      @facts["user"][key] = {
+        "value" => value,
+        "updated_at" => Time.now.utc.iso8601
+      }
+      save_facts
+      "Remembered: user's #{key} is #{value}"
+    end
+
+    # Remember preference
+    # @param key [String] preference key
+    # @param value [String] preference value
+    # @return [String] confirmation message
+    def remember_preference(key, value)
+      @facts["preferences"][key] = {
+        "value" => value,
+        "updated_at" => Time.now.utc.iso8601
+      }
+      save_facts
+      "Remembered preference: #{key} = #{value}"
+    end
+
+    # Remember general context
+    # @param key [String] context key
+    # @param value [String] context value
+    # @return [String] confirmation message
+    def remember_context(key, value)
+      @facts["context"][key] = {
+        "value" => value,
+        "updated_at" => Time.now.utc.iso8601
+      }
+      save_facts
+      "Remembered: #{key}"
+    end
+
+    # Recall learned facts about a topic
+    # @param topic [String] topic name
+    # @return [Array, nil] learned facts or nil
+    def recall_learned(topic)
+      @facts["learned"][topic]
+    end
+
+    # Recall user info
+    # @param key [String, nil] specific key to recall, or nil for all
+    # @return [Hash, String, nil] user info
+    def recall_user(key = nil)
+      key ? @facts["user"][key] : @facts["user"]
+    end
+
+    # Recall preferences
+    # @param key [String, nil] specific key to recall, or nil for all
+    # @return [Hash, String, nil] preferences
+    def recall_preferences(key = nil)
+      key ? @facts["preferences"][key] : @facts["preferences"]
+    end
+
+    # === Recent events ===
+
+    # Add a recent event
+    # @param description [String] event description
+    # @param category [String] event category (default: "general")
+    # @return [void]
+    def add_event(description, category: "general")
+      @recent.unshift({
+                        "category" => category,
+                        "description" => description,
+                        "timestamp" => Time.now.utc.iso8601
+                      })
+      @recent = @recent.first(MAX_RECENT)
+      save_recent
+    end
+
+    # Get recent events
+    # @param count [Integer] number of events to return (default: 10)
+    # @return [Array<Hash>] recent events
+    def recent_events(count = 10)
+      @recent.first(count)
+    end
+
+    # === Context building for LLM ===
+
+    # Get relevant memories for a message
+    # @param message [String] message to find relevant context for
+    # @param max_facts [Integer] maximum number of facts to include (default: 10)
+    # @return [String] formatted context string
+    def relevant_context(message, max_facts: 10)
+      message_lower = message.downcase
+      parts = []
+
+      # User info
+      if @facts["user"].any?
+        user_info = @facts["user"].map { |k, v| "#{k}: #{v["value"]}" }.join(", ")
+        parts << "USER: #{user_info}"
+      end
+
+      # Preferences
+      if @facts["preferences"].any?
+        prefs = @facts["preferences"].map { |k, v| "#{k}: #{v["value"]}" }.join(", ")
+        parts << "PREFERENCES: #{prefs}"
+      end
+
+      # Learned facts matching keywords
+      matched_facts = 0
+      @facts["learned"].each do |topic, entries|
+        break if matched_facts >= max_facts
+
+        next unless message_lower.include?(topic.downcase)
+
+        info = begin
+          entries.last["info"]
+        rescue StandardError
+          entries.to_s
+        end
+        parts << "KNOWN ABOUT #{topic}: #{info}"
+        matched_facts += 1
+      end
+
+      # Context items matching keywords
+      @facts["context"].each do |key, data|
+        break if matched_facts >= max_facts
+
+        if message_lower.include?(key.downcase)
+          parts << "#{key.upcase}: #{data["value"]}"
+          matched_facts += 1
+        end
+      end
+
+      # Recent events (last 5)
+      if @recent.any?
+        recent = @recent.first(5).map { |e| "- #{e["description"]}" }.join("\n")
+        parts << "RECENT:\n#{recent}"
+      end
+
+      parts.join("\n\n")
+    end
+
+    # Search across all memories
+    # @param query [String] search query
+    # @return [Array<Hash>] search results
+    def search(query)
+      results = []
+      query_lower = query.downcase
+
+      # Search learned facts
+      @facts["learned"].each do |topic, entries|
+        next unless topic.downcase.include?(query_lower)
+
+        entries.each do |entry|
+          results << {
+            type: "learned",
+            topic: topic,
+            content: entry["info"],
+            date: entry["learned_at"]
+          }
+        end
+      end
+
+      # Search user info
+      @facts["user"].each do |key, data|
+        next unless key.downcase.include?(query_lower) || data["value"].to_s.downcase.include?(query_lower)
+
+        results << {
+          type: "user",
+          key: key,
+          value: data["value"],
+          date: data["updated_at"]
+        }
+      end
+
+      # Search preferences
+      @facts["preferences"].each do |key, data|
+        next unless key.downcase.include?(query_lower) || data["value"].to_s.downcase.include?(query_lower)
+
+        results << {
+          type: "preference",
+          key: key,
+          value: data["value"],
+          date: data["updated_at"]
+        }
+      end
+
+      # Search context
+      @facts["context"].each do |key, data|
+        next unless key.downcase.include?(query_lower) || data["value"].to_s.downcase.include?(query_lower)
+
+        results << {
+          type: "context",
+          key: key,
+          value: data["value"],
+          date: data["updated_at"]
+        }
+      end
+
+      results
+    end
+
+    # Get memory statistics
+    def stats
+      {
+        learned_topics: @facts["learned"].keys.size,
+        total_learned: @facts["learned"].values.sum(&:size),
+        user_facts: @facts["user"].size,
+        preferences: @facts["preferences"].size,
+        context_items: @facts["context"].size,
+        recent_events: @recent.size
+      }
+    end
+
+    # Dump all memories (for debugging)
+    def dump_all
+      {
+        "facts" => @facts,
+        "recent" => @recent
+      }
+    end
+
+    private
+
+    def load_json(path)
+      return nil unless path.exist? # Missing file OK (first run)
+
+      content = path.read
+      JSON.parse(content)
+    rescue JSON::ParserError => e
+      raise Pocketrb::ConfigurationError,
+            "Invalid JSON in #{path}: #{e.message}\nContent preview: #{content[0..100]}"
+    end
+
+    def save_facts
+      @facts_file.write(JSON.pretty_generate(@facts))
+    end
+
+    def save_recent
+      @recent_file.write(JSON.pretty_generate(@recent))
+    end
+  end
+end

data/lib/pocketrb/planning/manager.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pocketrb
+  module Planning
+    # Manages plans persistence and lifecycle
+    class Manager
+      attr_reader :workspace
+
+      def initialize(workspace:)
+        @workspace = Pathname.new(workspace)
+        @plans_dir = @workspace.join(".pocketrb", "plans")
+        @plans_cache = {}
+
+        ensure_plans_dir!
+      end
+
+      # Create a new plan
+      # @param name [String] Plan name
+      # @param steps [Array<String>] Step descriptions
+      # @param description [String] Plan description
+      # @return [Plan]
+      def create_plan(name:, steps:, description: nil)
+        raise Error, "Plan '#{name}' already exists" if exists?(name)
+
+        plan = Plan.new(name: name, description: description)
+        plan.add_steps(steps)
+
+        save_plan(plan)
+        @plans_cache[name] = plan
+
+        Pocketrb.logger.info("Created plan: #{name} with #{steps.length} steps")
+        plan
+      end
+
+      # Get a plan by name
+      # @param name [String] Plan name
+      # @return [Plan|nil]
+      def get_plan(name)
+        @plans_cache[name] ||= load_plan(name)
+      end
+
+      # Update a plan
+      # @param name [String] Plan name
+      # @param completed_step [Integer] Step index to mark complete
+      # @param new_steps [Array<String>] Steps to add
+      # @param notes [String] Notes for completed step
+      def update_plan(name:, completed_step: nil, new_steps: nil, notes: nil)
+        plan = get_plan(name)
+        raise Error, "Plan '#{name}' not found" unless plan
+
+        plan.complete_step(completed_step, notes: notes) if completed_step
+
+        plan.add_steps(new_steps) if new_steps
+
+        # Auto-complete plan if all steps done
+        plan.mark_complete! if plan.complete? && plan.status == Plan::PlanStatus::ACTIVE
+
+        save_plan(plan)
+        plan
+      end
+
+      # Fail a step in a plan
+      def fail_step(name:, step_index:, notes: nil)
+        plan = get_plan(name)
+        raise Error, "Plan '#{name}' not found" unless plan
+
+        plan.fail_step(step_index, notes: notes)
+        save_plan(plan)
+        plan
+      end
+
+      # Activate a plan
+      def activate_plan(name)
+        plan = get_plan(name)
+        raise Error, "Plan '#{name}' not found" unless plan
+
+        plan.activate!
+        save_plan(plan)
+        plan
+      end
+
+      # Mark a plan as complete
+      def mark_complete(name)
+        plan = get_plan(name)
+        raise Error, "Plan '#{name}' not found" unless plan
+
+        plan.mark_complete!
+        save_plan(plan)
+        plan
+      end
+
+      # Cancel a plan
+      def cancel_plan(name)
+        plan = get_plan(name)
+        raise Error, "Plan '#{name}' not found" unless plan
+
+        plan.cancel!
+        save_plan(plan)
+        plan
+      end
+
+      # Delete a plan
+      def delete_plan(name)
+        file = plan_file(name)
+        File.delete(file) if file.exist?
+        @plans_cache.delete(name)
+      end
+
+      # Get all active plans
+      # @return [Array<Plan>]
+      def get_active_plans
+        list_plans.select { |p| p.status == Plan::PlanStatus::ACTIVE }
+      end
+
+      # Get all plans
+      # @return [Array<Plan>]
+      def list_plans
+        Dir.glob(@plans_dir.join("*.json")).filter_map do |file|
+          name = File.basename(file, ".json")
+          get_plan(name)
+        end
+      end
+
+      # Check if a plan exists
+      def exists?(name)
+        plan_file(name).exist?
+      end
+
+      private
+
+      def ensure_plans_dir!
+        FileUtils.mkdir_p(@plans_dir) unless @plans_dir.exist?
+      end
+
+      def plan_file(name)
+        safe_name = name.gsub(/[^a-zA-Z0-9_-]/, "_")
+        @plans_dir.join("#{safe_name}.json")
+      end
+
+      def save_plan(plan)
+        file = plan_file(plan.name)
+        File.write(file, JSON.pretty_generate(plan.to_h))
+      end
+
+      def load_plan(name)
+        file = plan_file(name)
+        return nil unless file.exist?
+
+        data = JSON.parse(File.read(file))
+        Plan.from_h(data)
+      rescue JSON::ParserError => e
+        Pocketrb.logger.error("Failed to parse plan #{name}: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/pocketrb/planning/plan.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Planning
+    # Represents an execution plan with steps
+    class Plan
+      attr_reader :name, :description, :steps, :created_at, :metadata
+      attr_accessor :status
+
+      # Step statuses
+      module StepStatus
+        PENDING = "pending"
+        IN_PROGRESS = "in_progress"
+        COMPLETED = "completed"
+        FAILED = "failed"
+        SKIPPED = "skipped"
+      end
+
+      # Plan statuses
+      module PlanStatus
+        DRAFT = "draft"
+        ACTIVE = "active"
+        COMPLETED = "completed"
+        FAILED = "failed"
+        CANCELLED = "cancelled"
+      end
+
+      Step = Data.define(:index, :description, :status, :notes, :completed_at) do
+        def initialize(index:, description:, status: StepStatus::PENDING, notes: nil, completed_at: nil)
+          super
+        end
+
+        def pending?
+          status == StepStatus::PENDING
+        end
+
+        def completed?
+          status == StepStatus::COMPLETED
+        end
+
+        def failed?
+          status == StepStatus::FAILED
+        end
+
+        def to_h
+          {
+            index: index,
+            description: description,
+            status: status,
+            notes: notes,
+            completed_at: completed_at&.iso8601
+          }.compact
+        end
+      end
+
+      def initialize(name:, description: nil, steps: [], status: PlanStatus::DRAFT, metadata: {})
+        @name = name
+        @description = description
+        @steps = steps.map.with_index do |step, idx|
+          step.is_a?(Step) ? step : Step.new(index: idx, description: step.to_s)
+        end
+        @status = status
+        @metadata = metadata
+        @created_at = Time.now
+      end
+
+      # Add a step to the plan
+      def add_step(description)
+        step = Step.new(index: @steps.length, description: description)
+        @steps << step
+        step
+      end
+
+      # Add multiple steps
+      def add_steps(descriptions)
+        descriptions.each { |d| add_step(d) }
+      end
+
+      # Update a step's status
+      def update_step(index, status:, notes: nil)
+        return nil unless @steps[index]
+
+        completed_at = status == StepStatus::COMPLETED ? Time.now : nil
+
+        @steps[index] = Step.new(
+          index: index,
+          description: @steps[index].description,
+          status: status,
+          notes: notes || @steps[index].notes,
+          completed_at: completed_at
+        )
+
+        @steps[index]
+      end
+
+      # Mark a step as completed
+      def complete_step(index, notes: nil)
+        update_step(index, status: StepStatus::COMPLETED, notes: notes)
+      end
+
+      # Mark a step as failed
+      def fail_step(index, notes: nil)
+        update_step(index, status: StepStatus::FAILED, notes: notes)
+      end
+
+      # Skip a step
+      def skip_step(index, notes: nil)
+        update_step(index, status: StepStatus::SKIPPED, notes: notes)
+      end
+
+      # Get the next pending step
+      def next_step
+        @steps.find(&:pending?)
+      end
+
+      # Get current step (in progress or next pending)
+      def current_step
+        @steps.find { |s| s.status == StepStatus::IN_PROGRESS } || next_step
+      end
+
+      # Check if plan is complete
+      def complete?
+        @steps.all?(&:completed?)
+      end
+
+      # Check if plan has failed
+      def failed?
+        @steps.any?(&:failed?)
+      end
+
+      # Get progress percentage
+      def progress
+        return 0 if @steps.empty?
+
+        completed = @steps.count(&:completed?)
+        (completed.to_f / @steps.length * 100).round
+      end
+
+      # Activate the plan
+      def activate!
+        @status = PlanStatus::ACTIVE
+      end
+
+      # Mark plan as complete
+      def mark_complete!
+        @status = PlanStatus::COMPLETED
+      end
+
+      # Mark plan as failed
+      def mark_failed!
+        @status = PlanStatus::FAILED
+      end
+
+      # Cancel the plan
+      def cancel!
+        @status = PlanStatus::CANCELLED
+      end
+
+      # Format as markdown
+      def to_markdown
+        lines = ["# Plan: #{@name}"]
+        lines << "" << @description if @description
+        lines << "" << "Status: #{@status} | Progress: #{progress}%"
+        lines << "" << "## Steps" << ""
+
+        @steps.each do |step|
+          checkbox = case step.status
+                     when StepStatus::COMPLETED then "[x]"
+                     when StepStatus::IN_PROGRESS then "[~]"
+                     when StepStatus::FAILED then "[!]"
+                     when StepStatus::SKIPPED then "[-]"
+                     else "[ ]"
+                     end
+
+          lines << "#{checkbox} #{step.index + 1}. #{step.description}"
+          lines << "   Notes: #{step.notes}" if step.notes
+        end
+
+        lines.join("\n")
+      end
+
+      # Convert to hash for serialization
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          steps: @steps.map(&:to_h),
+          status: @status,
+          metadata: @metadata,
+          created_at: @created_at.iso8601,
+          progress: progress
+        }
+      end
+
+      # Create from hash
+      def self.from_h(hash)
+        steps = (hash[:steps] || hash["steps"] || []).map do |s|
+          Step.new(
+            index: s[:index] || s["index"],
+            description: s[:description] || s["description"],
+            status: s[:status] || s["status"] || StepStatus::PENDING,
+            notes: s[:notes] || s["notes"],
+            completed_at: s[:completed_at] || s["completed_at"] ? Time.parse(s[:completed_at] || s["completed_at"]) : nil
+          )
+        end
+
+        plan = new(
+          name: hash[:name] || hash["name"],
+          description: hash[:description] || hash["description"],
+          steps: steps,
+          status: hash[:status] || hash["status"] || PlanStatus::DRAFT,
+          metadata: hash[:metadata] || hash["metadata"] || {}
+        )
+
+        if hash[:created_at] || hash["created_at"]
+          plan.instance_variable_set(:@created_at, Time.parse(hash[:created_at] || hash["created_at"]))
+        end
+
+        plan
+      end
+    end
+  end
+end