htm 0.0.18 → 0.0.30

data/lib/htm/models/robot_node.rb

@@ -7,48 +7,67 @@ class HTM
     # This model represents the relationship between a robot and a node,
     # tracking when and how many times a robot has "remembered" a piece of content.
     #
-    # @example Find all robots that remember a node
-    #   node.robots
-    #
-    # @example Find all nodes a robot remembers
-    #   robot.nodes
-    #
-    # @example Track remember activity
-    #   link = RobotNode.find_by(robot: robot, node: node)
-    #   link.remember_count  # => 3
-    #   link.first_remembered_at
-    #   link.last_remembered_at
-    #
-    class RobotNode < ActiveRecord::Base
-      self.table_name = 'robot_nodes'
+    class RobotNode < Sequel::Model(:robot_nodes)
+      # Associations
+      many_to_one :robot, class: 'HTM::Models::Robot', key: :robot_id
+      many_to_one :node, class: 'HTM::Models::Node', key: :node_id
+
+      # Plugins
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: true
+
+      # Validations
+      def validate
+        super
+        validates_presence [:robot_id, :node_id]
+        validates_unique [:robot_id, :node_id], message: 'already linked to this node'
+      end
+
+      # Dataset methods (scopes)
+      dataset_module do
+        def active
+          where(deleted_at: nil)
+        end
+
+        def recent
+          order(Sequel.desc(:last_remembered_at))
+        end
 
-      belongs_to :robot, class_name: 'HTM::Models::Robot'
-      belongs_to :node, class_name: 'HTM::Models::Node'
+        def by_robot(robot_id)
+          where(robot_id: robot_id)
+        end
 
-      validates :robot_id, presence: true
-      validates :node_id, presence: true
-      validates :robot_id, uniqueness: { scope: :node_id, message: 'already linked to this node' }
+        def by_node(node_id)
+          where(node_id: node_id)
+        end
 
-      # Scopes
-      # Soft delete - by default, only show non-deleted entries
-      default_scope { where(deleted_at: nil) }
+        def frequently_remembered
+          where { remember_count > 1 }.order(Sequel.desc(:remember_count))
+        end
 
-      scope :recent, -> { order(last_remembered_at: :desc) }
-      scope :by_robot, ->(robot_id) { where(robot_id: robot_id) }
-      scope :by_node, ->(node_id) { where(node_id: node_id) }
-      scope :frequently_remembered, -> { where('remember_count > 1').order(remember_count: :desc) }
-      scope :in_working_memory, -> { where(working_memory: true) }
+        def in_working_memory
+          where(working_memory: true)
+        end
 
-      # Soft delete scopes
-      scope :deleted, -> { unscoped.where.not(deleted_at: nil) }
-      scope :with_deleted, -> { unscoped }
+        def deleted
+          exclude(deleted_at: nil)
+        end
+
+        def with_deleted
+          unfiltered
+        end
+      end
+
+      # Apply default scope for active records
+      set_dataset(dataset.where(Sequel[:robot_nodes][:deleted_at] => nil))
 
       # Soft delete - mark as deleted without removing from database
       #
       # @return [Boolean] true if soft deleted successfully
       #
       def soft_delete!
-        update!(deleted_at: Time.current)
+        update(deleted_at: Time.now)
+        true
       end
 
       # Restore a soft-deleted entry
@@ -56,7 +75,8 @@ class HTM
       # @return [Boolean] true if restored successfully
       #
       def restore!
-        update!(deleted_at: nil)
+        update(deleted_at: nil)
+        true
       end
 
       # Check if entry is soft-deleted
@@ -64,7 +84,15 @@ class HTM
       # @return [Boolean] true if deleted_at is set
       #
       def deleted?
-        deleted_at.present?
+        !deleted_at.nil?
+      end
+
+      # Check if this node is in working memory
+      #
+      # @return [Boolean] true if working_memory is set
+      #
+      def working_memory?
+        !!working_memory
       end
 
       # Record that a robot remembered this content again
@@ -73,8 +101,8 @@ class HTM
       #
       def record_remember!
         self.remember_count += 1
-        self.last_remembered_at = Time.current
-        save!
+        self.last_remembered_at = Time.now
+        save
         self
       end
     end

data/lib/htm/models/tag.rb

@@ -4,79 +4,117 @@ class HTM
   module Models
     # Tag model - represents unique tag names
     # Tags have a many-to-many relationship with nodes through node_tags
-    class Tag < ActiveRecord::Base
-      self.table_name = 'tags'
-
+    class Tag < Sequel::Model(:tags)
       # Associations
-      has_many :node_tags, class_name: 'HTM::Models::NodeTag', dependent: :destroy
-      has_many :nodes, through: :node_tags, class_name: 'HTM::Models::Node'
+      one_to_many :node_tags, class: 'HTM::Models::NodeTag', key: :tag_id
+      many_to_many :nodes, class: 'HTM::Models::Node',
+                   join_table: :node_tags, left_key: :tag_id, right_key: :node_id
+
+      # Plugins
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: true
+
+      # Tag name format regex
+      TAG_FORMAT = /\A[a-z0-9\-]+(:[a-z0-9\-]+)*\z/
 
       # Validations
-      validates :name, presence: true
-      validates :name, format: {
-        with: /\A[a-z0-9\-]+(:[a-z0-9\-]+)*\z/,
-        message: "must be lowercase with hyphens, using colons for hierarchy (e.g., 'database:postgresql:performance')"
-      }
-      validates :name, uniqueness: { message: "already exists" }
-
-      # Callbacks
-      before_create :set_created_at
-
-      # Scopes
-      # Soft delete - by default, only show non-deleted tags
-      default_scope { where(deleted_at: nil) }
-
-      scope :by_name, ->(name) { where(name: name) }
-      scope :with_prefix, ->(prefix) { where("name LIKE ?", "#{prefix}%") }
-      scope :hierarchical, -> { where("name LIKE '%:%'") }
-      scope :root_level, -> { where("name NOT LIKE '%:%'") }
-
-      # Soft delete scopes
-      scope :deleted, -> { unscoped.where.not(deleted_at: nil) }
-      scope :with_deleted, -> { unscoped }
-
-      # Orphaned tags - tags with no active (non-deleted) node associations
-      scope :orphaned, -> {
-        where(
-          "NOT EXISTS (
-            SELECT 1 FROM node_tags
-            JOIN nodes ON nodes.id = node_tags.node_id
-            WHERE node_tags.tag_id = tags.id
-            AND node_tags.deleted_at IS NULL
-            AND nodes.deleted_at IS NULL
-          )"
-        )
-      }
+      def validate
+        super
+        validates_presence :name
+        validates_format TAG_FORMAT, :name,
+          message: "must be lowercase with hyphens, using colons for hierarchy (e.g., 'database:postgresql:performance')"
+        validates_unique :name, message: "already exists"
+      end
+
+      # Dataset methods (scopes)
+      dataset_module do
+        # Soft delete - by default, only show non-deleted tags
+        def active
+          where(deleted_at: nil)
+        end
+
+        def by_name(name)
+          where(name: name)
+        end
+
+        def with_prefix(prefix)
+          where(Sequel.like(:name, "#{prefix}%"))
+        end
+
+        def hierarchical
+          where(Sequel.like(:name, '%:%'))
+        end
+
+        def root_level
+          exclude(Sequel.like(:name, '%:%'))
+        end
+
+        def deleted
+          exclude(deleted_at: nil)
+        end
+
+        def with_deleted
+          unfiltered
+        end
+
+        # Orphaned tags - tags with no active (non-deleted) node associations
+        def orphaned
+          where(
+            Sequel.lit(
+              "NOT EXISTS (
+                SELECT 1 FROM node_tags
+                JOIN nodes ON nodes.id = node_tags.node_id
+                WHERE node_tags.tag_id = tags.id
+                AND node_tags.deleted_at IS NULL
+                AND nodes.deleted_at IS NULL
+              )"
+            )
+          )
+        end
+      end
+
+      # Apply default scope for active records
+      set_dataset(dataset.where(Sequel[:tags][:deleted_at] => nil))
+
+      # Hooks
+      def before_create
+        self.created_at ||= Time.now
+        super
+      end
 
       # Class methods
 
+      # Check if a tag exists with the given conditions
+      #
+      # @param conditions [Hash] Conditions to check
+      # @return [Boolean] true if a matching tag exists
+      #
+      def self.exists?(conditions = {})
+        where(conditions).any?
+      end
+
       # Find tags with a given prefix (hierarchical query)
       #
       # @param prefix [String] Tag prefix to match (e.g., "database" matches "database:postgresql")
-      # @return [ActiveRecord::Relation] Tags matching the prefix
-      #
-      # @example Find all database-related tags
-      #   Tag.find_by_topic_prefix("database")
-      #   # => [#<Tag name: "database:postgresql">, #<Tag name: "database:mysql">]
+      # @return [Sequel::Dataset] Tags matching the prefix
       #
       def self.find_by_topic_prefix(prefix)
-        where("name LIKE ?", "#{prefix}%")
+        dataset.with_prefix(prefix)
       end
 
       # Get the most frequently used tags
       #
       # @param limit [Integer] Maximum number of tags to return (default: 10)
-      # @return [ActiveRecord::Relation] Tags with usage_count attribute
-      #
-      # @example Get top 5 most used tags
-      #   Tag.popular_tags(5).each { |t| puts "#{t.name}: #{t.usage_count}" }
+      # @return [Array<Tag>] Tags with usage_count attribute
       #
       def self.popular_tags(limit = 10)
-        joins(:node_tags)
-          .select('tags.*, COUNT(node_tags.id) as usage_count')
-          .group('tags.id')
-          .order('usage_count DESC')
+        dataset
+          .select_append { count(node_tags[:id]).as(usage_count) }
+          .join(:node_tags, tag_id: :id)
+          .group(:id)
+          .order(Sequel.desc(:usage_count))
           .limit(limit)
+          .all
       end
 
       # Find or create a tag by name
@@ -85,25 +123,40 @@ class HTM
       # @return [Tag] The found or created tag
       #
       def self.find_or_create_by_name(name)
-        find_or_create_by(name: name)
+        find_or_create(name: name)
       end
 
-      # Returns a nested hash tree structure from the current scope
+      # Expand a hierarchical tag name into all ancestor paths
       #
-      # @return [Hash] Nested hash representing the tag hierarchy
+      # @param tag_name [String] Hierarchical tag (e.g., "a:b:c:d")
+      # @return [Array<String>] All paths from root to leaf
       #
-      # @example Get all tags as a tree
-      #   Tag.all.tree
-      #   # => { "database" => { "postgresql" => {}, "mysql" => {} }, "ai" => { "llm" => {} } }
+      def self.expand_hierarchy(tag_name)
+        return [] if tag_name.nil? || tag_name.empty?
+
+        levels = tag_name.split(':')
+        (1..levels.size).map { |i| levels[0, i].join(':') }
+      end
+
+      # Find or create a tag and all its ancestor tags
       #
-      # @example Get filtered tags as a tree
-      #   Tag.with_prefix("database").tree
-      #   # => { "database" => { "postgresql" => {} } }
+      # @param name [String] Hierarchical tag name (e.g., "database:postgresql:extensions")
+      # @return [Array<Tag>] All created/found tags from root to leaf
+      #
+      def self.find_or_create_with_ancestors(name)
+        expand_hierarchy(name).map do |tag_name|
+          find_or_create(name: tag_name)
+        end
+      end
+
+      # Returns a nested hash tree structure from the current scope
+      #
+      # @return [Hash] Nested hash representing the tag hierarchy
       #
       def self.tree
         tree = {}
 
-        all.order(:name).pluck(:name).each do |tag_name|
+        order(:name).select_map(:name).each do |tag_name|
           parts = tag_name.split(':')
           current = tree
 
@@ -118,24 +171,13 @@ class HTM
 
       # Returns a formatted string representation of the tag tree
       #
-      # Uses directory-style formatting with ├── and └── characters
-      #
       # @return [String] Formatted tree string
       #
-      # @example Display all tags as a tree
-      #   puts Tag.all.tree_string
-      #   # ├── ai
-      #   # │   └── llm
-      #   # └── database
-      #   #     └── postgresql
-      #
       def self.tree_string
         format_tree_branch(tree)
       end
 
       # Returns a Mermaid flowchart representation of the tag tree
-      # Example: puts Tag.all.tree_mermaid
-      # Example: Tag.all.tree_mermaid(direction: 'LR') # Left to right
       #
       # @param direction [String] Flow direction: 'TD' (top-down), 'LR' (left-right), 'BT', 'RL'
       # @return [String] Mermaid flowchart syntax
@@ -148,15 +190,12 @@ class HTM
         node_id = 0
         node_ids = {}
 
-        # Generate Mermaid nodes and connections
         generate_mermaid_nodes(tree_data, nil, lines, node_ids, node_id)
 
         lines.join("\n")
       end
 
       # Returns an SVG representation of the tag tree
-      # Uses dark theme with transparent background
-      # Example: File.write('tags.svg', Tag.all.tree_svg)
       #
       # @param title [String] Optional title for the SVG
       # @return [String] SVG markup
@@ -165,28 +204,22 @@ class HTM
         tree_data = tree
         return empty_tree_svg(title) if tree_data.empty?
 
-        # Calculate dimensions based on tree structure
         stats = calculate_tree_stats(tree_data)
-        node_count = stats[:total_nodes]
         max_depth = stats[:max_depth]
 
-        # Layout constants
         node_width = 140
         node_height = 30
         h_spacing = 180
         v_spacing = 50
         padding = 40
 
-        # Calculate positions for all nodes
         positions = {}
-        y_offset = [0]  # Use array to allow mutation in closure
+        y_offset = [0]
         calculate_node_positions(tree_data, 0, positions, y_offset, h_spacing, v_spacing)
 
-        # Calculate SVG dimensions
         width = (max_depth * h_spacing) + node_width + (padding * 2)
         height = (y_offset[0] * v_spacing) + node_height + (padding * 2)
 
-        # Generate SVG
         generate_tree_svg(tree_data, positions, width, height, padding, node_width, node_height, title)
       end
 
@@ -198,14 +231,11 @@ class HTM
         sorted_keys.each_with_index do |key, index|
           is_last = (index == sorted_keys.size - 1)
 
-          # Build prefix from parent branches
-          line_prefix = is_last_array.map { |was_last| was_last ? '    ' : '│   ' }.join
+          line_prefix = is_last_array.map { |was_last| was_last ? '    ' : '|   ' }.join
 
-          # Add branch character and key
-          branch = is_last ? '└── ' : '├── '
+          branch = is_last ? '+-- ' : '+-- '
           result += "#{line_prefix}#{branch}#{key}\n"
 
-          # Recurse into children
           children = node[key]
           unless children.empty?
             result += format_tree_branch(children, is_last_array + [is_last])
@@ -220,20 +250,16 @@ class HTM
         node.keys.sort.each do |key|
           current_path = parent_path ? "#{parent_path}:#{key}" : key
 
-          # Create unique node ID
           node_id = "n#{counter}"
           node_ids[current_path] = node_id
           counter += 1
 
-          # Add node definition with styling
           lines << "  #{node_id}[\"#{key}\"]"
 
-          # Add connection from parent
           if parent_path && node_ids[parent_path]
             lines << "  #{node_ids[parent_path]} --> #{node_id}"
           end
 
-          # Recurse into children
           children = node[key]
           counter = generate_mermaid_nodes(children, current_path, lines, node_ids, counter) unless children.empty?
         end
@@ -287,17 +313,14 @@ class HTM
 
       # Generate SVG tree visualization (internal helper)
       def self.generate_tree_svg(tree_data, positions, width, height, padding, node_width, node_height, title)
-        # Color palette for different depths (dark theme)
         colors = ['#3B82F6', '#8B5CF6', '#EC4899', '#F59E0B', '#10B981', '#6366F1']
 
         svg_lines = []
         svg_lines << %(<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{width} #{height + 40}">)
         svg_lines << '  <rect width="100%" height="100%" fill="transparent"/>'
 
-        # Title
         svg_lines << %Q(  <text x="#{width / 2}" y="25" text-anchor="middle" fill="#F3F4F6" font-family="system-ui, sans-serif" font-size="16" font-weight="bold">#{title}</text>)
 
-        # Draw connections first (so they appear behind nodes)
         positions.each do |path, pos|
           parent_path = path.include?(':') ? path.split(':')[0..-2].join(':') : nil
           next unless parent_path && positions[parent_path]
@@ -308,12 +331,10 @@ class HTM
           x2 = padding + (pos[:x] * (node_width + 40))
           y2 = 40 + padding + (pos[:y] * (node_height + 20)) + (node_height / 2)
 
-          # Curved connection line
           mid_x = (x1 + x2) / 2
           svg_lines << %Q(  <path d="M#{x1},#{y1} C#{mid_x},#{y1} #{mid_x},#{y2} #{x2},#{y2}" stroke="#4B5563" stroke-width="2" fill="none"/>)
         end
 
-        # Draw nodes
         positions.each do |path, pos|
           depth = path.count(':')
           color = colors[depth % colors.size]
@@ -321,10 +342,8 @@ class HTM
           x = padding + (pos[:x] * (node_width + 40))
           y = 40 + padding + (pos[:y] * (node_height + 20))
 
-          # Node rectangle with rounded corners
           svg_lines << %Q(  <rect x="#{x}" y="#{y}" width="#{node_width}" height="#{node_height}" rx="6" fill="#{color}" opacity="0.9"/>)
 
-          # Node label
           text_x = x + (node_width / 2)
           text_y = y + (node_height / 2) + 4
           svg_lines << %Q(  <text x="#{text_x}" y="#{text_y}" text-anchor="middle" fill="#FFFFFF" font-family="system-ui, sans-serif" font-size="11" font-weight="500">#{pos[:label]}</text>)
@@ -340,10 +359,6 @@ class HTM
       #
       # @return [String] The first segment of the hierarchical tag
       #
-      # @example
-      #   tag = Tag.find_by(name: "database:postgresql:extensions")
-      #   tag.root_topic  # => "database"
-      #
       def root_topic
         name.split(':').first
       end
@@ -352,10 +367,6 @@ class HTM
       #
       # @return [Array<String>] Array of topic segments
       #
-      # @example
-      #   tag = Tag.find_by(name: "database:postgresql:extensions")
-      #   tag.topic_levels  # => ["database", "postgresql", "extensions"]
-      #
       def topic_levels
         name.split(':')
       end
@@ -364,10 +375,6 @@ class HTM
       #
       # @return [Integer] Number of hierarchy levels
       #
-      # @example
-      #   Tag.find_by(name: "database").depth           # => 1
-      #   Tag.find_by(name: "database:postgresql").depth  # => 2
-      #
       def depth
         topic_levels.length
       end
@@ -385,7 +392,7 @@ class HTM
       # @return [Integer] Count of nodes with this tag
       #
       def usage_count
-        node_tags.count
+        node_tags_dataset.count
       end
 
       # Soft delete - mark tag as deleted without removing from database
@@ -393,7 +400,8 @@ class HTM
       # @return [Boolean] true if soft deleted successfully
       #
       def soft_delete!
-        update!(deleted_at: Time.current)
+        update(deleted_at: Time.now)
+        true
       end
 
       # Restore a soft-deleted tag
@@ -401,7 +409,8 @@ class HTM
       # @return [Boolean] true if restored successfully
       #
       def restore!
-        update!(deleted_at: nil)
+        update(deleted_at: nil)
+        true
       end
 
       # Check if tag is soft-deleted
@@ -409,13 +418,7 @@ class HTM
       # @return [Boolean] true if deleted_at is set
       #
       def deleted?
-        deleted_at.present?
-      end
-
-      private
-
-      def set_created_at
-        self.created_at ||= Time.current
+        !deleted_at.nil?
       end
     end
   end