robot_lab 0.1.0 → 0.2.1

data/examples/27_incident_response/incident_response.rb

@@ -38,11 +38,9 @@
 
 ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "../prompts")
 
-require_relative "../../lib/robot_lab"
+require_relative "../common"
 require "fileutils"
 
-RubyLLM.configure { |c| c.logger = Logger.new(File::NULL) }
-
 OUTPUT_DIR = File.join(__dir__, "output")
 FileUtils.mkdir_p(OUTPUT_DIR)
 
@@ -62,6 +60,7 @@ class SREScout < RobotLab::Robot
   def initialize(name:, subsystem:, memory_key:, bus: nil)
     super(
       name: name,
+      model: LLM[:default].model,
       system_prompt: "You are a senior SRE responding to a production outage. " \
                      "Diagnose one infrastructure layer in 2 sentences: " \
                      "first sentence is root cause, second is customer impact.",
@@ -112,7 +111,7 @@ class WarRoom < RobotLab::Robot
   attr_reader :updates
 
   def initialize(bus:)
-    super(name: "war_room", system_prompt: "SRE war-room coordinator.", bus: bus)
+    super(name: "war_room", model: LLM[:default].model, system_prompt: "SRE war-room coordinator.", bus: bus)
     @updates        = []
     @delivery_mutex = Mutex.new  # only for reading @updates outside Async
 
@@ -178,7 +177,7 @@ db_scout  = SREScout.new(name: "db_scout",  subsystem: "database",    memory_key
 net_scout = SREScout.new(name: "net_scout", subsystem: "network",     memory_key: :net_finding, bus: bus)
 app_scout = SREScout.new(name: "app_scout", subsystem: "application", memory_key: :app_finding, bus: bus)
 war_room  = WarRoom.new(bus: bus)
-commander = IncidentCommander.new(name: "commander", system_prompt: "SRE incident commander.")
+commander = IncidentCommander.new(name: "commander", model: LLM[:default].model, system_prompt: "SRE incident commander.")
 
 # Build the investigation network
 # poller_group: labels are registered on the network's shared BusPoller.

data/examples/28_mcp_discovery.rb

@@ -12,6 +12,7 @@
 # == Key config
 #
 #   robot = RobotLab.build(
+#     model: "gpt-5.4",
 #     mcp_discovery: true,    # ← enables semantic filtering
 #     mcp: [ ... ]            # ← candidate servers, each with :description
 #   )
@@ -29,7 +30,7 @@
 # Usage:
 #   bundle exec ruby examples/28_mcp_discovery.rb
 
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # Three representative MCP server configurations
 SERVERS = [
@@ -59,10 +60,8 @@ def show_query(label, query)
   puts
 end
 
-puts "=" * 60
-puts "Example 28: MCP Server Discovery"
+banner "MCP Server Discovery"
 puts "  Semantic server selection via TF cosine similarity"
-puts "=" * 60
 puts
 puts "Candidate servers:"
 SERVERS.each do |s|
@@ -70,14 +69,12 @@ SERVERS.each do |s|
 end
 puts
 
-puts "Discovery queries:"
-puts "-" * 60
+section "Discovery Queries"
 show_query("File ops",     "read my config file")
 show_query("Package mgmt", "install imagemagick via homebrew")
 show_query("Code review",  "list open pull requests on my repo")
 
-puts "Fallback cases:"
-puts "-" * 60
+section "Fallback Cases"
 
 # No description → all servers returned
 no_desc_servers = SERVERS.map { |s| s.except(:description) }
@@ -93,10 +90,10 @@ result = RobotLab::MCP::ServerDiscovery.select("install imagemagick", from: SERV
 puts "  High threshold  : returns all (#{result.size} servers) — no match above 1.0"
 
 puts
-puts "mcp_discovery: true on a Robot"
-puts "-" * 60
+section "mcp_discovery: true on a Robot"
 puts <<~NOTE
   RobotLab.build(
+  model: "gpt-5.4",
     name: "assistant",
     mcp_discovery: true,
     mcp: [
@@ -109,4 +106,4 @@ puts <<~NOTE
   # Only the :brew server is connected for this message:
   robot.run("install imagemagick")
 NOTE
-puts "=" * 60
+hr

data/examples/29_ractor_tools.rb

@@ -26,9 +26,8 @@
 #   SHA-256 rounds (~320 ms on modern hardware) so the 4-6× speedup is
 #   clearly visible on a 6-core machine.
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
+require "robot_lab/ractor"
 require "digest"
 
 # Always shut down the pool when the process exits.
@@ -115,10 +114,7 @@ end
 # Demo
 # =============================================================================
 
-puts "=" * 62
-puts "Example 29: Ractor-Safe CPU Tools"
-puts "=" * 62
-puts
+banner "Ractor-Safe CPU Tools"
 
 DIVIDER = ("─" * 54).freeze
 
@@ -238,6 +234,5 @@ puts "    #{DIVIDER}"
 RobotLab.shutdown_ractor_pool
 puts "    Pool shut down cleanly (poison-pill × #{pool.size} workers)."
 puts
-puts "=" * 62
+hr
 puts "Example 29 complete."
-puts "=" * 62

data/examples/30_ractor_network.rb

@@ -30,14 +30,10 @@
 #   bundle exec ruby examples/30_ractor_network.rb              # Parts 1 & 2
 #   ANTHROPIC_API_KEY=key ruby examples/30_ractor_network.rb    # Parts 1, 2 & 3
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
+require_relative "common"
+require "robot_lab/ractor"
 
-require_relative "../lib/robot_lab"
-
-puts "=" * 62
-puts "Example 30: Ractor Network Scheduler"
-puts "=" * 62
-puts
+banner "Ractor Network Scheduler"
 
 DIVIDER = ("─" * 54).freeze
 
@@ -73,8 +69,7 @@ LATENCIES = {
 #
 #   Speedup    ≈ 1.7×
 
-puts "── Part 1: Simulated parallel run (no API key) ───────────"
-puts
+section "Part 1: Simulated Parallel Run (no API key)"
 
 # SimulatedScheduler overrides execute_spec so that instead of
 # constructing a real Robot and calling the LLM, it just sleeps for
@@ -140,14 +135,13 @@ puts
 # Part 2: Network.new(parallel_mode: :ractor) API
 # =============================================================================
 
-puts "── Part 2: Network.new(parallel_mode: :ractor) ───────────"
-puts
+section "Part 2: Network.new(parallel_mode: :ractor)"
 
 # When parallel_mode: :ractor is set on a Network, network.run(message:)
 # routes through RactorNetworkScheduler instead of SimpleFlow::Pipeline.
 # The default mode is :async (unchanged SimpleFlow behavior).
 
-model = "claude-haiku-4-5-20251001"
+model = LLM[:default].model
 
 network = RobotLab::Network.new(name: "research_pipeline", parallel_mode: :ractor) do
   task :headline_finder,  RobotLab.build(name: "headline_finder",
@@ -197,19 +191,17 @@ puts
 # =============================================================================
 
 unless ENV["ANTHROPIC_API_KEY"]
-  puts "── Part 3: Live LLM run ──────────────────────────────────"
+  section "Part 3: Live LLM Run"
   puts "   Set ANTHROPIC_API_KEY to run the real pipeline."
   puts "   Expected behavior: headline_finder, background_brief, and"
   puts "   fact_checker run in parallel; report_writer follows."
   puts
-  puts "=" * 62
+  hr
   puts "Example 30 complete."
-  puts "=" * 62
   exit 0
 end
 
-puts "── Part 3: Live LLM run (ANTHROPIC_API_KEY detected) ─────"
-puts
+section "Part 3: Live LLM Run (ANTHROPIC_API_KEY detected)"
 
 puts "  Running 4-robot research pipeline on:"
 puts "  \"#{topic}\""
@@ -251,6 +243,5 @@ rescue RobotLab::Error => e
 end
 
 puts
-puts "=" * 62
+hr
 puts "Example 30 complete."
-puts "=" * 62

data/examples/31_launch_assessment.rb

@@ -47,11 +47,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/31_launch_assessment.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
-
-RubyLLM.configure { |c| c.logger = Logger.new(File::NULL) }
+require_relative "common"
 
 # ── AnalystRobot ────────────────────────────────────────────────────────────────
 #
@@ -65,6 +61,7 @@ class AnalystRobot < RobotLab::Robot
   def initialize(name:, memory_key:, role:)
     super(
       name:          name,
+      model:         LLM[:default].model,
       system_prompt: "You are a #{role}. " \
                      "Review the product brief in 2-3 crisp sentences from your area of expertise. " \
                      "Close with a one-word verdict: READY or NOT-READY."
@@ -172,6 +169,7 @@ end
 
 director = LaunchDirector.new(
   name:          "launch_director",
+  model:         LLM[:default].model,
   system_prompt: "You are the VP of Product making the final launch call."
 )
 
@@ -202,10 +200,8 @@ end
 
 # ── Run ─────────────────────────────────────────────────────────────────────────
 
-puts "=" * 68
-puts "Example 31: Product Launch Assessment"
+banner "Product Launch Assessment"
 puts "  6 specialist analysts in parallel, max_concurrent_robots: 4"
-puts "=" * 68
 puts
 puts "Pipeline:"
 puts network.visualize
@@ -215,30 +211,21 @@ puts
 puts "Product brief:"
 puts PRODUCT_BRIEF.strip.gsub(/^/, "  ")
 puts
-puts "-" * 68
-puts "Running — analysts 5 and 6 queue until a semaphore slot opens..."
-puts "-" * 68
-puts
+section "Running — Analysts 5 and 6 Queue Until a Semaphore Slot Opens"
 
 $run_start = Time.now
 result     = network.run(message: PRODUCT_BRIEF)
 elapsed    = "%.1f" % (Time.now - $run_start)
 
 puts
-puts "-" * 68
+hr
 puts "All analysts complete. Total wall time: #{elapsed}s"
-puts "-" * 68
-puts
-puts "=" * 68
-puts "LAUNCH DIRECTOR RECOMMENDATION"
-puts "=" * 68
-puts
+hr
+
+section "Launch Director Recommendation"
 puts network.memory[:recommendation]
 puts
-puts "=" * 68
-puts "INDIVIDUAL ANALYST VERDICTS"
-puts "=" * 68
-puts
+section "Individual Analyst Verdicts"
 analyst_robots.each do |robot|
   label  = robot.name.gsub("_", " ").upcase
   finding = network.memory.get(robot.memory_key).to_s

data/examples/32_newsletter_reader.rb

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example 32: Newsletter Issue Retriever
+#
+# Fetches all unprocessed issues from multiple Ruby newsletters via RSS
+# and saves each as a Markdown file in the Obsidian Clippings folder.
+#
+# - Processes oldest unprocessed issue first (across all feeds)
+# - Filename: <newsletter-name>_YYYYMMDD.md
+# - Includes YAML frontmatter with source URL (compatible with Clippings workflow)
+# - Tracks processed issue URLs in ~/.robot_lab/newsletter_processed.yaml
+#
+# Usage:
+#   ruby examples/32_newsletter_reader.rb
+
+require "net/http"
+require "open3"
+require "time"
+require "uri"
+require "yaml"
+require "fileutils"
+require "rexml/document"
+require "rexml/xpath"
+
+NEWSLETTER_RSS_URLS = [
+  "https://rss.beehiiv.com/feeds/MTJunJRFxo.xml",       # Ruby AI News
+  "https://cprss.s3.amazonaws.com/rubyweekly.com.xml"   # Ruby Weekly
+].freeze
+
+CLIPPINGS_DIR        = File.expand_path("/Users/dewayne/Documents/obsidian_order_intelligence/PKM/Clippings")
+PROCESSED_STATE_FILE = File.join(Dir.home, ".robot_lab", "newsletter_processed.yaml")
+
+# Tracks which newsletter issue URLs have been saved.
+class ProcessedIssues
+  def initialize(path: PROCESSED_STATE_FILE)
+    @path = path
+    @urls = load_urls
+  end
+
+  def processed?(url)
+    @urls.include?(url)
+  end
+
+  def mark_processed(url)
+    @urls << url
+    FileUtils.mkdir_p(File.dirname(@path))
+    File.write(@path, YAML.dump(@urls.uniq))
+  end
+
+  def count = @urls.size
+
+  private
+
+  def load_urls
+    return [] unless File.exist?(@path)
+    Array(YAML.safe_load(File.read(@path)) || [])
+  end
+end
+
+# Fetches a single RSS feed URL and returns its items (unsorted).
+# Each item: { title:, url:, pub_date:, published_at:, html:, channel_name: }
+def fetch_rss_items(url)
+  uri      = URI(url)
+  response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |h| h.get(uri.request_uri) }
+  raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+  doc  = REXML::Document.new(response.body)
+  ns   = { "content" => "http://purl.org/rss/1.0/modules/content/" }
+
+  channel_title = REXML::XPath.first(doc, "//channel/title")&.text&.strip || "newsletter"
+
+  REXML::XPath.match(doc, "//channel/item").filter_map do |item|
+    item_url = REXML::XPath.first(item, "link")&.text&.strip
+    title    = REXML::XPath.first(item, "title")&.text&.strip
+    pub_date = REXML::XPath.first(item, "pubDate")&.text&.strip
+    html     = REXML::XPath.first(item, "content:encoded", ns)&.text ||
+               REXML::XPath.first(item, "description")&.text || ""
+
+    next unless item_url && title && pub_date
+
+    {
+      title:        title,
+      url:          item_url,
+      pub_date:     pub_date,
+      published_at: Time.parse(pub_date),
+      html:         html,
+      channel_name: channel_title
+    }
+  end
+end
+
+# Fetches all configured RSS feeds and returns items sorted oldest-first.
+def fetch_all_rss_items
+  NEWSLETTER_RSS_URLS.flat_map do |feed_url|
+    print "  #{feed_url}... "
+    items = fetch_rss_items(feed_url)
+    puts "#{items.size} issues"
+    items
+  end.sort_by { |item| item[:published_at] }
+end
+
+# Converts HTML to Markdown via html2markdown CLI, stripping UTM params.
+def html_to_markdown(html)
+  md, = Open3.capture3(
+    "html2markdown",
+    stdin_data: html
+  )
+  md.gsub(/\]\(([^)]+)\)/) do
+    url = $1
+    if url.include?("?")
+      base, query = url.split("?", 2)
+      kept = query.split("&").reject { |p| p.start_with?("utm_") }
+      "](#{kept.empty? ? base : "#{base}?#{kept.join("&")}"})"
+    else
+      "](#{url})"
+    end
+  end
+end
+
+# Builds the output filename: <newsletter-name>_YYYYMMDD.md
+def output_filename(channel_name, published_at)
+  safe_name = channel_name.downcase.gsub(/[^a-z0-9]+/, "_").delete_suffix("_")
+  date_str  = published_at.strftime("%Y%m%d")
+  "#{safe_name}_#{date_str}.md"
+end
+
+# Wraps markdown content in YAML frontmatter compatible with the Clippings workflow.
+def wrap_with_frontmatter(title:, url:, pub_date:, body:)
+  date = Time.parse(pub_date).strftime("%Y-%m-%d")
+  <<~MD
+    ---
+    source: #{url}
+    title: "#{title.gsub('"', '\\"')}"
+    date: #{date}
+    ---
+
+    # #{title}
+
+    #{body.strip}
+  MD
+end
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+puts "=" * 60
+puts "Example 32: Newsletter Issue Retriever"
+puts "=" * 60
+puts
+
+FileUtils.mkdir_p(CLIPPINGS_DIR)
+state = ProcessedIssues.new
+
+puts "Fetching #{NEWSLETTER_RSS_URLS.size} RSS feeds..."
+all_items = fetch_all_rss_items
+pending   = all_items.reject { |item| state.processed?(item[:url]) }
+puts "#{all_items.size} total issues found across all feeds."
+
+if pending.empty?
+  puts "All issues already saved. Nothing to do."
+  exit
+end
+
+puts "#{pending.size} unprocessed (#{state.count} already done). Saving oldest-first."
+puts
+
+pending.each_with_index do |item, idx|
+  filename = output_filename(item[:channel_name], item[:published_at])
+  filepath = File.join(CLIPPINGS_DIR, filename)
+
+  print "[#{idx + 1}/#{pending.size}] #{item[:title]} (#{item[:published_at].strftime("%Y-%m-%d")})... "
+
+  body     = html_to_markdown(item[:html])
+  content  = wrap_with_frontmatter(
+    title:    item[:title],
+    url:      item[:url],
+    pub_date: item[:pub_date],
+    body:     body
+  )
+
+  File.write(filepath, content)
+  state.mark_processed(item[:url])
+
+  puts "saved → #{filename}"
+end
+
+puts
+puts "Done. #{pending.size} issue(s) saved to #{CLIPPINGS_DIR}"

data/examples/33_stock_generator.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example 33: XYZZY Stock Price Generator
+#
+# Publishes fake streaming prices for ticker XYZZY to a Redis channel
+# using Geometric Brownian Motion with occasional volatility regime shifts.
+#
+# Prerequisites:
+#   gem install redis
+#   Redis server running on localhost:6379
+#
+# Usage:
+#   ruby examples/33_stock_generator.rb
+
+require "redis"
+require "json"
+require "time"
+
+CHANNEL     = "stock:xyzzy"
+START_PRICE = 100.0
+BASE_VOL    = 0.008   # baseline volatility per tick (~0.8%)
+DRIFT       = 0.0001  # slight upward drift per tick
+
+# Box-Muller transform — standard normal sample
+def randn
+  Math.sqrt(-2.0 * Math.log(rand)) * Math.cos(2.0 * Math::PI * rand)
+end
+
+# Occasionally shift the volatility regime to create interesting price dynamics
+def current_volatility(tick)
+  case tick % 60
+  when 0..10  then BASE_VOL * 2.0   # high volatility burst
+  when 30..35 then BASE_VOL * 0.4   # low volatility squeeze
+  else             BASE_VOL
+  end
+end
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+redis = Redis.new
+price = START_PRICE
+tick  = 0
+
+trap("INT") { puts "\nGenerator stopped."; exit }
+
+puts "=" * 50
+puts "XYZZY Stock Generator"
+puts "=" * 50
+puts "Channel : #{CHANNEL}"
+puts "Interval: 5 seconds per tick"
+puts "Model   : Geometric Brownian Motion"
+puts "Press Ctrl-C to stop."
+puts "-" * 50
+
+loop do
+  tick += 1
+
+  vol   = current_volatility(tick)
+  price = (price * Math.exp((DRIFT - 0.5 * vol**2) + vol * randn)).round(2)
+  price = [price, 1.0].max  # floor at $1.00
+
+  regime = case vol
+           when BASE_VOL * 2.0 then " [HIGH VOL]"
+           when BASE_VOL * 0.4 then " [low vol]"
+           else ""
+           end
+
+  payload = JSON.generate(
+    ticker:    "XYZZY",
+    price:     price,
+    tick:      tick,
+    timestamp: Time.now.iso8601
+  )
+
+  redis.publish(CHANNEL, payload)
+  puts "Tick %5d  $%8.2f  vol=%.3f%s" % [tick, price, vol, regime]
+
+  sleep 5
+end