intent-record 1.0.0

data/lib/intent_record/linkers/asset_version_linker.rb

@@ -0,0 +1,43 @@
+require_relative "../models/vcs_system"
+require_relative "../models/asset_version"
+require_relative "../models/intent_record_asset_version"
+require_relative "../asset_version_normalizer"
+require_relative "asset_version_specs"
+
+module IntentRecord
+  module Linkers
+    # Links an intent record to the asset versions a payload names. Reading the
+    # payload is AssetVersionSpecs; this writes the rows. Returns the versions.
+    class AssetVersionLinker
+      def self.call(record, input)
+        new(record).call(input)
+      end
+
+      def initialize(record)
+        @record = record
+      end
+
+      def call(input)
+        AssetVersionSpecs.from(input).map { |vcs, external_id| link!(vcs, external_id) }
+      end
+
+      private
+
+      def link!(raw_vcs, raw_id)
+        vcs = AssetVersionNormalizer.vcs_name(raw_vcs)
+        version = find_or_create_version(vcs, AssetVersionNormalizer.external_id(vcs, raw_id))
+        Models::IntentRecordAssetVersion.find_or_create_by!(intent_record: @record, asset_version: version) do |l|
+          l.created_at = Time.now.utc
+        end
+        version
+      end
+
+      def find_or_create_version(vcs, external_id)
+        system = Models::VcsSystem.find_or_create_by!(name: vcs) { |s| s.created_at = Time.now.utc }
+        Models::AssetVersion.find_or_create_by!(vcs_system: system, external_id: external_id) do |v|
+          v.created_at = Time.now.utc
+        end
+      end
+    end
+  end
+end

data/lib/intent_record/linkers/asset_version_specs.rb

@@ -0,0 +1,30 @@
+require_relative "../input_validator"
+
+module IntentRecord
+  module Linkers
+    # Reads the asset versions a payload asks for, as [vcs, external_id] pairs.
+    # `commits` is git shorthand; `asset_versions` names its own system. Every
+    # entry is checked before any is returned, so a payload with a bad entry
+    # later in the list never reaches the database.
+    module AssetVersionSpecs
+      DEFAULT_VCS = "git".freeze
+
+      module_function
+
+      def from(input)
+        commits(input).map { |c| [DEFAULT_VCS, c] } + explicit(input).map { |v| [v["vcs"], v["external_id"]] }
+      end
+
+      def commits(input)
+        InputValidator.non_blank_strings!(InputValidator.array!(input, "commits"), "commit")
+      end
+
+      def explicit(input)
+        InputValidator.hashes_with!(InputValidator.array!(input, "asset_versions"),
+                                    "asset_versions", "vcs", "external_id")
+      end
+
+      private_class_method :commits, :explicit
+    end
+  end
+end

data/lib/intent_record/linkers/intent_linker.rb

@@ -0,0 +1,35 @@
+require_relative "../models/intent_record"
+require_relative "../models/intent_record_link"
+require_relative "../input_validator"
+
+module IntentRecord
+  module Linkers
+    # Links an intent record to earlier intent records it builds on (`related_intent_ids`).
+    class IntentLinker
+      def self.call(record, input)
+        new(record).call(input)
+      end
+
+      def initialize(record)
+        @record = record
+      end
+
+      def call(input)
+        ids = InputValidator.non_blank_strings!(InputValidator.array!(input, "related_intent_ids"), "related_intent_id")
+        ids.map { |id| link!(id) }
+      end
+
+      private
+
+      def link!(global_id)
+        raise ValidationError, "An intent record cannot link to itself" if global_id == @record.global_id
+
+        target = Models::IntentRecord.find_by(global_id: global_id)
+        raise NotFoundError, "Related intent record not found: #{global_id}" unless target
+
+        Models::IntentRecordLink.find_or_create_by!(source: @record, target: target) { |l| l.created_at = Time.now.utc }
+        target
+      end
+    end
+  end
+end

data/lib/intent_record/linkers/stakeholder_linker.rb

@@ -0,0 +1,61 @@
+require_relative "../models/stakeholder_system"
+require_relative "../models/stakeholder_source"
+require_relative "../models/stakeholder_reference"
+require_relative "../input_validator"
+require_relative "../stakeholder_normalizer"
+
+module IntentRecord
+  module Linkers
+    # Links an intent record to stakeholder sources given as [{system, uri, title?}].
+    # A source is unique per (system, uri), so the same ticket referenced under two
+    # systems is two sources.
+    #
+    # A non-blank title replaces the stored one. A title that is missing, null or
+    # blank leaves it alone, which means a title cannot be cleared once stored.
+    # Where one payload names the same source twice, the last title in it wins.
+    class StakeholderLinker
+      def self.call(record, input)
+        new(record).call(input)
+      end
+
+      def initialize(record)
+        @record = record
+      end
+
+      def call(input)
+        refs = InputValidator.hashes_with!(InputValidator.array!(input, "stakeholder_references"),
+                                           "stakeholder_references", "system", "uri")
+        refs.map { |ref| link!(ref) }
+      end
+
+      private
+
+      def link!(ref)
+        source = find_or_create_source(ref)
+        Models::StakeholderReference.find_or_create_by!(intent_record: @record, stakeholder_source: source) do |r|
+          r.created_at = Time.now.utc
+        end
+        source
+      end
+
+      def find_or_create_source(ref)
+        source = initialized_source(ref)
+        title = InputValidator.optional_string!(ref, "title")
+        source.title = title if title
+        source.created_at ||= Time.now.utc
+        source.save!
+        source
+      end
+
+      def initialized_source(ref)
+        system = find_or_create_system(StakeholderNormalizer.system_name(ref["system"]))
+        Models::StakeholderSource.find_or_initialize_by(stakeholder_system: system,
+                                                        uri: StakeholderNormalizer.uri(ref["uri"]))
+      end
+
+      def find_or_create_system(name)
+        Models::StakeholderSystem.find_or_create_by!(name: name) { |s| s.created_at = Time.now.utc }
+      end
+    end
+  end
+end

data/lib/intent_record/models/asset_version.rb

@@ -0,0 +1,12 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class AssetVersion < ApplicationRecord
+      belongs_to :vcs_system
+      has_many :intent_record_asset_versions, dependent: :destroy
+      has_many :intent_records, through: :intent_record_asset_versions
+
+      validates :external_id, presence: true, uniqueness: { scope: :vcs_system_id }
+    end
+  end
+end

data/lib/intent_record/models/intent_record.rb

@@ -0,0 +1,29 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class IntentRecord < ApplicationRecord
+      SUMMARY_MAX_LENGTH = 350
+
+      # Ordered by the link rows, so a caller reads a record's commits, references
+      # and related intents back in the order they attached them. Without an
+      # order the answer is whatever the query plan produces, which is not
+      # insertion order: SQLite answers from a covering index where it can.
+      ATTACHMENT_ORDER = -> { order(:id) }
+
+      has_many :intent_record_asset_versions, ATTACHMENT_ORDER, dependent: :destroy
+      has_many :asset_versions, through: :intent_record_asset_versions
+      has_many :stakeholder_references, ATTACHMENT_ORDER, dependent: :destroy
+      has_many :stakeholder_sources, through: :stakeholder_references
+      has_many :outgoing_links, ATTACHMENT_ORDER, class_name: "IntentRecord::Models::IntentRecordLink",
+                                                  foreign_key: :source_intent_record_id, dependent: :destroy,
+                                                  inverse_of: :source
+      has_many :incoming_links, ATTACHMENT_ORDER, class_name: "IntentRecord::Models::IntentRecordLink",
+                                                  foreign_key: :target_intent_record_id, dependent: :destroy,
+                                                  inverse_of: :target
+
+      validates :global_id, presence: true, length: { is: GlobalId::LENGTH }, uniqueness: true
+      validates :summary, presence: true, length: { maximum: SUMMARY_MAX_LENGTH }
+      validates :body, presence: true
+    end
+  end
+end

data/lib/intent_record/models/intent_record_asset_version.rb

@@ -0,0 +1,11 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class IntentRecordAssetVersion < ApplicationRecord
+      belongs_to :intent_record
+      belongs_to :asset_version
+
+      validates :intent_record_id, uniqueness: { scope: :asset_version_id }
+    end
+  end
+end

data/lib/intent_record/models/intent_record_link.rb

@@ -0,0 +1,22 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class IntentRecordLink < ApplicationRecord
+      belongs_to :source, class_name: "IntentRecord::Models::IntentRecord",
+                          foreign_key: :source_intent_record_id, inverse_of: :outgoing_links
+      belongs_to :target, class_name: "IntentRecord::Models::IntentRecord",
+                          foreign_key: :target_intent_record_id, inverse_of: :incoming_links
+
+      validates :source_intent_record_id, uniqueness: { scope: :target_intent_record_id }
+      validate :not_self_referencing
+
+      private
+
+      def not_self_referencing
+        return unless source_intent_record_id && source_intent_record_id == target_intent_record_id
+
+        errors.add(:base, "An intent record cannot link to itself")
+      end
+    end
+  end
+end

data/lib/intent_record/models/stakeholder_reference.rb

@@ -0,0 +1,11 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class StakeholderReference < ApplicationRecord
+      belongs_to :intent_record
+      belongs_to :stakeholder_source
+
+      validates :intent_record_id, uniqueness: { scope: :stakeholder_source_id }
+    end
+  end
+end

data/lib/intent_record/models/stakeholder_source.rb

@@ -0,0 +1,12 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class StakeholderSource < ApplicationRecord
+      belongs_to :stakeholder_system
+      has_many :stakeholder_references, dependent: :destroy
+      has_many :intent_records, through: :stakeholder_references
+
+      validates :uri, presence: true, uniqueness: { scope: :stakeholder_system_id }
+    end
+  end
+end

data/lib/intent_record/models/stakeholder_system.rb

@@ -0,0 +1,10 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class StakeholderSystem < ApplicationRecord
+      has_many :stakeholder_sources, dependent: :restrict_with_exception
+
+      validates :name, presence: true, uniqueness: true
+    end
+  end
+end

data/lib/intent_record/models/vcs_system.rb

@@ -0,0 +1,10 @@
+require_relative "../application_record"
+module IntentRecord
+  module Models
+    class VcsSystem < ApplicationRecord
+      has_many :asset_versions, dependent: :restrict_with_exception
+
+      validates :name, presence: true, uniqueness: true
+    end
+  end
+end

data/lib/intent_record/seeds.rb

@@ -0,0 +1,38 @@
+require_relative "models/vcs_system"
+require_relative "models/stakeholder_system"
+
+module IntentRecord
+  # Well-known systems seeded on every connect so the store works out of the box.
+  # Names are lowercase, hyphenated; user-supplied names are normalised the same way.
+  module Seeds
+    VCS_SYSTEMS = %w[
+      git mercurial subversion perforce fossil bazaar cvs darcs pijul sapling plastic-scm
+    ].freeze
+
+    STAKEHOLDER_SYSTEMS = %w[
+      jira confluence linear
+      github-issues github-pull-requests github-discussions github-projects
+      gitlab-issues gitlab-merge-requests gitlab-epics
+      bitbucket azure-devops azure-boards
+      trello asana notion monday clickup basecamp shortcut youtrack pivotal-tracker
+      slack microsoft-teams discord email
+      google-docs google-sheets sharepoint dropbox-paper coda
+      figma miro lucidchart
+      servicenow zendesk intercom freshdesk
+      productboard aha airfocus
+      doors polarion jama codebeamer
+      adr rfc wiki web
+    ].freeze
+
+    def self.apply!
+      seed!(Models::VcsSystem, VCS_SYSTEMS)
+      seed!(Models::StakeholderSystem, STAKEHOLDER_SYSTEMS)
+    end
+
+    def self.seed!(model, names)
+      existing = model.where(name: names).pluck(:name)
+      now = Time.now.utc
+      (names - existing).each { |name| model.create!(name: name, created_at: now) }
+    end
+  end
+end

data/lib/intent_record/sqlite_connection_setup.rb

@@ -0,0 +1,22 @@
+require "active_record"
+require "active_record/connection_adapters/sqlite3_adapter"
+
+module IntentRecord
+  # Applied to every pooled SQLite connection: pragmas, and a Unicode-aware ULOWER() so
+  # case-insensitive search works for non-ASCII letters (SQLite's LOWER folds ASCII only).
+  module SqliteConnectionSetup
+    BUSY_TIMEOUT_MS = 5_000
+    PRAGMAS = ["PRAGMA foreign_keys = ON", "PRAGMA journal_mode = WAL",
+               "PRAGMA busy_timeout = #{BUSY_TIMEOUT_MS}"].freeze
+
+    def configure_connection
+      super
+      PRAGMAS.each { |sql| @raw_connection.execute(sql) }
+      @raw_connection.create_function("ulower", 1) do |fn, value|
+        fn.result = value&.to_s&.downcase
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(SqliteConnectionSetup)
+end

data/lib/intent_record/stakeholder_normalizer.rb

@@ -0,0 +1,33 @@
+require "uri"
+
+module IntentRecord
+  # Normalises stakeholder system names and source URIs so the same ticket is one source.
+  module StakeholderNormalizer
+    module_function
+
+    def system_name(raw)
+      raw.strip.downcase.gsub(/[\s_]+/, "-")
+    end
+
+    # A value with neither scheme nor host is an opaque identifier such as a bare
+    # ticket key, and case is significant there. Anything else is a URI, whose
+    # scheme URI.parse has already downcased for us; only the host is left to do.
+    def uri(raw)
+      value = raw.strip
+      parsed = URI.parse(value)
+      return value.chomp("/") unless parsed.scheme || parsed.host
+
+      downcased_host(parsed).to_s.chomp("/")
+    rescue URI::InvalidURIError
+      value
+    end
+
+    def downcased_host(parsed)
+      return parsed unless parsed.host
+
+      normalized = parsed.dup
+      normalized.host = parsed.host.downcase
+      normalized
+    end
+  end
+end

data/lib/intent_record/version.rb

@@ -0,0 +1,3 @@
+module IntentRecord
+  VERSION = "1.0.0".freeze
+end

data/lib/intent_record/web/app.rb

@@ -0,0 +1,54 @@
+require "sinatra/base"
+require "erb"
+require_relative "query_router"
+require_relative "routes/home"
+require_relative "routes/commits"
+require_relative "routes/intents"
+require_relative "routes/search"
+require_relative "routes/sources"
+
+module IntentRecord
+  module Web
+    # Read-only local GUI. Expects the database to be connected before requests arrive.
+    class App < Sinatra::Base
+      set :host_authorization, { permitted_hosts: [] }
+      set :views, File.expand_path("views", __dir__)
+      set :public_folder, File.expand_path("public", __dir__)
+      set :static, true
+      set :show_exceptions, false
+      set :dump_errors, false
+
+      helpers do
+        def h(text)
+          ERB::Util.html_escape(text)
+        end
+
+        def intent_cards(records)
+          erb :_intent_cards, locals: { records: records }
+        end
+      end
+
+      error NotFoundError do
+        status 404
+        erb :error, locals: { title: "Not found", message: env["sinatra.error"].message }
+      end
+
+      error ValidationError do
+        status 400
+        erb :error, locals: { title: "Cannot answer that", message: env["sinatra.error"].message }
+      end
+
+      error StandardError do
+        status 500
+        env["rack.errors"].puts "#{env["sinatra.error"].class}: #{env["sinatra.error"].message}"
+        erb :error, locals: { title: "Something went wrong", message: env["sinatra.error"].message }
+      end
+
+      register Routes::Home
+      register Routes::Commits
+      register Routes::Intents
+      register Routes::Search
+      register Routes::Sources
+    end
+  end
+end

data/lib/intent_record/web/boot.rb

@@ -0,0 +1,51 @@
+require_relative "../config"
+require_relative "../database"
+require_relative "app"
+require_relative "../cli/streams"
+
+module IntentRecord
+  module Web
+    # Boots the GUI on localhost only. Connects (and migrates) the database first.
+    module Boot
+      BIND = "127.0.0.1".freeze
+      DEFAULT_PORT = 4791
+      PORT_RANGE = (1..65_535)
+
+      Options = Struct.new(:port, keyword_init: true)
+
+      module_function
+
+      # Out of range, the bind fails with a resolution error that says nothing about
+      # ports, so reject it here rather than let the socket layer explain it badly.
+      # Leftovers are rejected here too, because serve forwards its argv straight
+      # to Boot and so never passes through Dispatch#finish!.
+      def parse_argv(argv)
+        parser = CLI::ArgvParser.new(argv)
+        port = parser.take_integer_flag("--port", DEFAULT_PORT)
+        parser.reject_leftovers!
+        raise ValidationError, "--port must be between #{PORT_RANGE.first} and #{PORT_RANGE.last}, got #{port}" \
+          unless PORT_RANGE.cover?(port)
+
+        Options.new(port: port)
+      end
+
+      def run!(config:, argv:, streams: CLI::Streams.default)
+        port = parse_argv(argv).port
+        config.load!
+        Database.connect!(config.db_path)
+        streams.stderr.puts "intent-record GUI on http://#{BIND}:#{port} (db: #{config.db_path})"
+        serve!(port)
+      end
+
+      # Only the bind itself can refuse a port, and Database.connect! has already
+      # translated its own permission failures, so these two reach here from App only.
+      def serve!(port)
+        App.run!(bind: BIND, port: port)
+      rescue Errno::EADDRINUSE
+        raise Error, "Port #{port} is already in use; pass --port to choose another"
+      rescue Errno::EACCES
+        raise Error, "Port #{port} needs elevated privileges; pass --port to choose another"
+      end
+    end
+  end
+end

data/lib/intent_record/web/public/styles.css

@@ -0,0 +1,50 @@
+:root {
+  --bg: #f7f9fb; --surface: #fff; --tint: #E8F4F8; --tint-strong: #C7E9F1;
+  --ink: #2a3b4a; --ink-soft: #506373; --ink-mute: #6b7c8c;
+  --border: rgba(42, 59, 74, 0.10); --border-soft: rgba(42, 59, 74, 0.05);
+  --shadow: 0 1px 3px rgba(42, 59, 74, 0.06); --radius: 12px; --radius-sm: 8px;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #14191e; --surface: #1d242b; --tint: #22303a; --tint-strong: #2d4351;
+    --ink: #e4ebf1; --ink-soft: #b3c0cc; --ink-mute: #8797a6;
+    --border: rgba(228, 235, 241, 0.14); --border-soft: rgba(228, 235, 241, 0.07);
+  }
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: var(--bg); color: var(--ink); font-size: 14px; line-height: 1.5; }
+a { color: inherit; text-decoration: none; }
+a:hover { text-decoration: underline; }
+code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.92em; }
+h1 { font-size: 22px; font-weight: 600; margin: 0 0 4px; }
+h2 { font-size: 16px; font-weight: 600; margin: 0 0 4px; }
+h3 { font-size: 12px; font-weight: 600; margin: 24px 0 8px; color: var(--ink-soft); text-transform: uppercase; letter-spacing: 0.05em; }
+.topnav { background: var(--surface); border-bottom: 1px solid var(--border-soft); padding: 10px 24px; display: flex; align-items: center; gap: 18px; box-shadow: var(--shadow); }
+.topnav .brand { font-weight: 700; padding-right: 14px; border-right: 1px solid var(--border-soft); }
+.topnav .lookup { display: flex; gap: 8px; flex: 1; max-width: 640px; }
+.topnav .lookup input { flex: 1; }
+.topnav .who { margin-left: auto; color: var(--ink-mute); font-size: 12px; }
+input[type="text"] { font: inherit; color: var(--ink); background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-sm); padding: 7px 10px; outline: none; }
+input[type="text"]:focus { border-color: var(--tint-strong); box-shadow: 0 0 0 3px var(--tint); }
+button { font: inherit; font-weight: 500; color: var(--ink); background: var(--tint); border: 1px solid var(--tint-strong); border-radius: var(--radius-sm); padding: 7px 14px; cursor: pointer; }
+button:hover { background: var(--tint-strong); }
+.page { max-width: 960px; margin: 0 auto; padding: 24px 16px 64px; }
+.page > header { margin-bottom: 20px; }
+.subtitle { color: var(--ink-mute); font-size: 13px; margin: 0; }
+.card { background: var(--surface); border-radius: var(--radius); box-shadow: var(--shadow); border: 1px solid var(--border-soft); padding: 18px; margin-bottom: 16px; }
+.card.muted { background: transparent; border: 1px dashed var(--border); box-shadow: none; }
+.card pre { background: var(--tint); padding: 10px 12px; border-radius: var(--radius-sm); overflow-x: auto; }
+.intent .meta { color: var(--ink-mute); font-size: 12px; margin-bottom: 10px; }
+.intent .body { white-space: pre-wrap; word-wrap: break-word; margin-bottom: 12px; }
+.links { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin-top: 6px; }
+.links .label { font-size: 11px; text-transform: uppercase; letter-spacing: 0.05em; color: var(--ink-mute); margin-right: 4px; }
+.chip { background: var(--tint); border: 1px solid var(--border-soft); border-radius: 999px; padding: 3px 10px; font-size: 12px; }
+.chip.ext::after { content: " ↗"; color: var(--ink-mute); }
+.empty { color: var(--ink-mute); font-style: italic; }
+.card.tint { background: var(--tint); }
+.commit-list { list-style: none; margin: 0; padding: 0; }
+.commit-list li { margin: 4px 0; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 13px; }
+.commit-list .chip { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; margin-right: 6px; }
+.footer { max-width: 960px; margin: 0 auto; padding: 0 16px 32px; color: var(--ink-mute); font-size: 12px; }
+.footer code { background: var(--tint); padding: 2px 6px; border-radius: 4px; }

data/lib/intent_record/web/query_router.rb

@@ -0,0 +1,25 @@
+require "uri"
+
+module IntentRecord
+  module Web
+    # Decides where a free-text query from the home page search box should go.
+    module QueryRouter
+      HEX = /\A[0-9a-f]{4,}\z/i
+
+      module_function
+
+      def path_for(raw)
+        query = raw.to_s.strip
+        return "/" if query.empty?
+        return "/commits/#{query}" if HEX.match?(query)
+        return "/sources?uri=#{URI.encode_www_form_component(query)}" if url?(query)
+
+        "/search?q=#{URI.encode_www_form_component(query)}"
+      end
+
+      def url?(query)
+        query.match?(%r{\A[a-z][a-z0-9+.-]*://}i)
+      end
+    end
+  end
+end

data/lib/intent_record/web/routes/commits.rb

@@ -0,0 +1,16 @@
+require_relative "../../commands/lookup"
+
+module IntentRecord
+  module Web
+    module Routes
+      module Commits
+        def self.registered(app)
+          app.get "/commits/:external_id" do
+            result = Commands::Lookup.new(external_id: params[:external_id], vcs: params[:vcs]).call
+            erb :commit, locals: { version: result["asset_version"], intents: result["intents"] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intent_record/web/routes/home.rb

@@ -0,0 +1,21 @@
+require_relative "../../commands/recent"
+require_relative "../query_router"
+
+module IntentRecord
+  module Web
+    module Routes
+      module Home
+        def self.registered(app)
+          app.get "/" do
+            recent = Commands::Recent.new(limit: 20).call
+            erb :home, locals: { recent: recent["intents"] }
+          end
+
+          app.get "/go" do
+            redirect QueryRouter.path_for(params[:q])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intent_record/web/routes/intents.rb

@@ -0,0 +1,15 @@
+require_relative "../../commands/show"
+
+module IntentRecord
+  module Web
+    module Routes
+      module Intents
+        def self.registered(app)
+          app.get "/intents/:id" do
+            erb :intent, locals: { intent: Commands::Show.new(intent_id: params[:id]).call }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intent_record/web/routes/search.rb

@@ -0,0 +1,17 @@
+require_relative "../../commands/search"
+
+module IntentRecord
+  module Web
+    module Routes
+      module Search
+        def self.registered(app)
+          app.get "/search" do
+            terms = params[:q].to_s.split
+            results = terms.empty? ? [] : Commands::Search.new(terms: terms, match: "all").call["intents"]
+            erb :search, locals: { query: params[:q].to_s, intents: results }
+          end
+        end
+      end
+    end
+  end
+end