htm 0.0.1 → 0.0.2

data/examples/sinatra_app/app.rb

@@ -22,8 +22,9 @@
 require 'sinatra'
 require 'sinatra/json'
 require 'sidekiq'
+require 'securerandom'
 require_relative '../../lib/htm'
-require_relative '../../lib/htm/sinatra'
+require_relative '../../lib/htm/integrations/sinatra'
 
 # Sidekiq configuration
 Sidekiq.configure_server do |config|
@@ -41,7 +42,11 @@ class HTMApp < Sinatra::Base
 
   # Enable sessions for robot identification
   enable :sessions
-  set :session_secret, ENV.fetch('SESSION_SECRET', 'change_me_in_production')
+  # Session secret must be at least 64 bytes for Rack session encryption
+  set :session_secret, ENV.fetch('SESSION_SECRET', SecureRandom.hex(64))
+
+  # Enable inline templates (defined after __END__)
+  enable :inline_templates
 
   # Initialize HTM for each request
   before do
@@ -66,7 +71,7 @@ class HTMApp < Sinatra::Base
       halt 400, json(error: 'Content is required')
     end
 
-    node_id = remember(content, source: 'web_user')
+    node_id = remember(content)
 
     json(
       status: 'ok',
@@ -80,6 +85,7 @@ class HTMApp < Sinatra::Base
     topic = params[:topic]
     limit = (params[:limit] || 10).to_i
     strategy = (params[:strategy] || 'hybrid').to_sym
+    timeframe_param = params[:timeframe]
 
     unless topic && !topic.empty?
       halt 400, json(error: 'Topic is required')
@@ -89,11 +95,16 @@ class HTMApp < Sinatra::Base
       halt 400, json(error: 'Invalid strategy. Use: vector, fulltext, or hybrid')
     end
 
-    memories = recall(topic, limit: limit, strategy: strategy, raw: true)
+    # Parse timeframe parameter (in seconds)
+    # Valid values: "5", "10", "15", "20", "25", "30", "30+", "all", or nil
+    timeframe = parse_timeframe_param(timeframe_param)
+
+    memories = recall(topic, limit: limit, strategy: strategy, timeframe: timeframe, raw: true)
 
     json(
       status: 'ok',
       count: memories.length,
+      timeframe: timeframe_param || 'all',
       memories: memories.map { |m| format_memory(m) }
     )
   end
@@ -105,7 +116,7 @@ class HTMApp < Sinatra::Base
     nodes_with_tags = HTM::Models::Node.joins(:tags).distinct.count
     total_tags = HTM::Models::Tag.count
 
-    robot_nodes = HTM::Models::Node.where(robot_id: htm.robot_id).count
+    robot_nodes = HTM::Models::RobotNode.where(robot_id: htm.robot_id).count
 
     json(
       status: 'ok',
@@ -133,16 +144,52 @@ class HTMApp < Sinatra::Base
     )
   end
 
+  # API: Get all tags as a tree structure
+  get '/api/tags' do
+    tags = HTM::Models::Tag.all
+
+    json(
+      status: 'ok',
+      count: tags.count,
+      tree: tags.tree
+    )
+  end
+
   private
 
+  # Parse timeframe parameter from query string
+  # Returns a string like "last N seconds" or nil for "all"
+  def parse_timeframe_param(param)
+    return nil if param.nil? || param.empty? || param == 'all'
+
+    case param
+    when '5', '10', '15', '20', '25', '30'
+      "last #{param} seconds"
+    when '30+'
+      # 30+ means older than 30 seconds (from beginning of time to 30 seconds ago)
+      thirty_seconds_ago = Time.now - 30
+      Time.at(0)..thirty_seconds_ago
+    else
+      nil  # Default to all time
+    end
+  end
+
   def format_memory(memory)
-    {
+    result = {
       id: memory['id'],
       content: memory['content'],
-      source: memory['source'],
       created_at: memory['created_at'],
       token_count: memory['token_count']
     }
+
+    # Include hybrid search scoring if available
+    if memory['similarity']
+      result[:similarity] = memory['similarity'].to_f.round(4)
+      result[:tag_boost] = memory['tag_boost'].to_f.round(4)
+      result[:combined_score] = memory['combined_score'].to_f.round(4)
+    end
+
+    result
   end
 
   # Run the app
@@ -201,11 +248,40 @@ __END__
       border-left-color: #dc3545;
       background: #fff5f5;
     }
+    .scores {
+      color: #6c757d;
+      font-style: italic;
+    }
+    .tag-tree {
+      font-family: monospace;
+      margin: 10px 0;
+      line-height: 1.4;
+    }
+    .filter-row {
+      display: flex;
+      gap: 10px;
+      margin: 10px 0;
+    }
+    .filter-row select {
+      flex: 1;
+      padding: 10px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+    }
+    .timeframe-badge {
+      display: inline-block;
+      background: #6c757d;
+      color: white;
+      padding: 2px 8px;
+      border-radius: 4px;
+      font-size: 0.85em;
+      margin-left: 8px;
+    }
   </style>
 </head>
 <body>
   <h1>HTM Sinatra Example</h1>
-  <p>Hierarchical Temporary Memory with Sidekiq background jobs</p>
+  <p>Hierarchical Temporary Memory with tag-enhanced hybrid search and Sidekiq background jobs</p>
 
   <div class="section">
     <h2>Remember Information</h2>
@@ -216,12 +292,25 @@ __END__
 
   <div class="section">
     <h2>Recall Memories</h2>
+    <p><small>Hybrid search uses combined scoring: (similarity × 0.7) + (tag_boost × 0.3)</small></p>
     <input type="text" id="recallTopic" placeholder="Enter topic to search...">
-    <select id="recallStrategy">
-      <option value="hybrid">Hybrid (Vector + Fulltext)</option>
-      <option value="vector">Vector Only</option>
-      <option value="fulltext">Fulltext Only</option>
-    </select>
+    <div class="filter-row">
+      <select id="recallStrategy">
+        <option value="hybrid">Hybrid (Vector + Fulltext + Tags)</option>
+        <option value="vector">Vector Only</option>
+        <option value="fulltext">Fulltext Only</option>
+      </select>
+      <select id="recallTimeframe">
+        <option value="all">All Time</option>
+        <option value="5">Last 5 seconds</option>
+        <option value="10">Last 10 seconds</option>
+        <option value="15">Last 15 seconds</option>
+        <option value="20">Last 20 seconds</option>
+        <option value="25">Last 25 seconds</option>
+        <option value="30">Last 30 seconds</option>
+        <option value="30+">Older than 30 seconds</option>
+      </select>
+    </div>
     <button onclick="recall()">Recall</button>
     <div id="recallResult"></div>
   </div>
@@ -232,6 +321,12 @@ __END__
     <div id="statsResult"></div>
   </div>
 
+  <div class="section">
+    <h2>Tag Tree</h2>
+    <button onclick="getTags()">Refresh</button>
+    <div id="tagsResult"></div>
+  </div>
+
   <script>
     async function remember() {
       const content = document.getElementById('rememberContent').value;
@@ -268,6 +363,7 @@ __END__
     async function recall() {
       const topic = document.getElementById('recallTopic').value;
       const strategy = document.getElementById('recallStrategy').value;
+      const timeframe = document.getElementById('recallTimeframe').value;
       const resultDiv = document.getElementById('recallResult');
 
       if (!topic) {
@@ -276,21 +372,33 @@ __END__
       }
 
       try {
-        const response = await fetch(`/api/recall?topic=${encodeURIComponent(topic)}&strategy=${strategy}&limit=10`);
+        const response = await fetch(`/api/recall?topic=${encodeURIComponent(topic)}&strategy=${strategy}&timeframe=${timeframe}&limit=10`);
         const data = await response.json();
 
         if (response.ok) {
           if (data.count === 0) {
             resultDiv.innerHTML = '<div class="result">No memories found</div>';
           } else {
-            const memoriesHtml = data.memories.map(m => `
-              <div class="result">
-                <strong>Node ${m.id}</strong> (${m.source})<br>
-                ${m.content}<br>
-                <small>${new Date(m.created_at).toLocaleString()} • ${m.token_count} tokens</small>
-              </div>
-            `).join('');
-            resultDiv.innerHTML = `<p>Found ${data.count} memories:</p>${memoriesHtml}`;
+            // Format timeframe for display
+            const timeframeDisplay = formatTimeframe(data.timeframe);
+            const memoriesHtml = data.memories.map(m => {
+              // Build scoring info if available (hybrid search)
+              let scoreInfo = '';
+              if (m.combined_score !== undefined) {
+                scoreInfo = `<br><small class="scores">Score: ${m.combined_score.toFixed(3)} (similarity: ${m.similarity.toFixed(3)}, tag boost: ${m.tag_boost.toFixed(3)})</small>`;
+              }
+              // Calculate age of memory
+              const age = formatAge(m.created_at);
+              return `
+                <div class="result">
+                  <strong>Node ${m.id}</strong> <span class="timeframe-badge">${age}</span><br>
+                  ${m.content}<br>
+                  <small>${new Date(m.created_at).toLocaleString()} • ${m.token_count} tokens</small>
+                  ${scoreInfo}
+                </div>
+              `;
+            }).join('');
+            resultDiv.innerHTML = `<p>Found ${data.count} memories (${timeframeDisplay}):</p>${memoriesHtml}`;
           }
         } else {
           resultDiv.innerHTML = `<div class="result error">✗ ${data.error}</div>`;
@@ -300,6 +408,36 @@ __END__
       }
     }
 
+    function formatTimeframe(tf) {
+      switch(tf) {
+        case 'all': return 'all time';
+        case '5': return 'last 5 seconds';
+        case '10': return 'last 10 seconds';
+        case '15': return 'last 15 seconds';
+        case '20': return 'last 20 seconds';
+        case '25': return 'last 25 seconds';
+        case '30': return 'last 30 seconds';
+        case '30+': return 'older than 30 seconds';
+        default: return tf;
+      }
+    }
+
+    function formatAge(createdAt) {
+      const now = new Date();
+      const created = new Date(createdAt);
+      const diffSeconds = Math.floor((now - created) / 1000);
+
+      if (diffSeconds < 60) {
+        return `${diffSeconds}s ago`;
+      } else if (diffSeconds < 3600) {
+        return `${Math.floor(diffSeconds / 60)}m ago`;
+      } else if (diffSeconds < 86400) {
+        return `${Math.floor(diffSeconds / 3600)}h ago`;
+      } else {
+        return `${Math.floor(diffSeconds / 86400)}d ago`;
+      }
+    }
+
     async function getStats() {
       const resultDiv = document.getElementById('statsResult');
 
@@ -328,8 +466,65 @@ __END__
       }
     }
 
-    // Load stats on page load
-    window.onload = getStats;
+    async function getTags() {
+      const resultDiv = document.getElementById('tagsResult');
+
+      try {
+        const response = await fetch('/api/tags');
+        const data = await response.json();
+
+        if (response.ok) {
+          if (data.count === 0) {
+            resultDiv.innerHTML = '<div class="result">No tags found</div>';
+          } else {
+            const treeHtml = renderTagTree(data.tree);
+            resultDiv.innerHTML = `
+              <div class="result">
+                <pre class="tag-tree">${treeHtml}</pre>
+                <small>${data.count} tags</small>
+              </div>
+            `;
+          }
+        } else {
+          resultDiv.innerHTML = `<div class="result error">✗ ${data.error}</div>`;
+        }
+      } catch (error) {
+        resultDiv.innerHTML = `<div class="result error">✗ ${error.message}</div>`;
+      }
+    }
+
+    function renderTagTree(tree, prefix = '', isLastArray = []) {
+      const keys = Object.keys(tree).sort();
+      let result = '';
+
+      keys.forEach((key, index) => {
+        const isLast = index === keys.length - 1;
+
+        // Build prefix from parent branches
+        let linePrefix = '';
+        isLastArray.forEach(wasLast => {
+          linePrefix += wasLast ? '    ' : '│   ';
+        });
+
+        // Add branch character
+        const branch = isLast ? '└── ' : '├── ';
+        result += linePrefix + branch + key + '\n';
+
+        // Recurse into children
+        const children = tree[key];
+        if (Object.keys(children).length > 0) {
+          result += renderTagTree(children, prefix, [...isLastArray, isLast]);
+        }
+      });
+
+      return result;
+    }
+
+    // Load stats and tags on page load
+    window.onload = function() {
+      getStats();
+      getTags();
+    };
   </script>
 </body>
 </html>

data/lib/htm/active_record_config.rb

@@ -53,9 +53,14 @@ class HTM
 
       # Check if connection is established and active
       def connected?
-        ActiveRecord::Base.connected? &&
-          ActiveRecord::Base.connection.active?
-      rescue StandardError
+        return false unless defined?(ActiveRecord::Base)
+        return false unless ActiveRecord::Base.connection_handler.connection_pool_list.any?
+
+        ActiveRecord::Base.connected? && ActiveRecord::Base.connection.active?
+      rescue ActiveRecord::ConnectionNotDefined, ActiveRecord::ConnectionNotEstablished
+        false
+      rescue StandardError => e
+        HTM.logger.debug "Connection check failed: #{e.class} - #{e.message}"
         false
       end
 
@@ -105,8 +110,10 @@ class HTM
       def require_models
         require_relative 'models/robot'
         require_relative 'models/node'
+        require_relative 'models/robot_node'
         require_relative 'models/tag'
         require_relative 'models/node_tag'
+        require_relative 'models/working_memory_entry'
       end
     end
   end