feat: add VeriSimDB connector and pattern detection

- lib/verisimdb_connector.ex: reads scan results from verisimdb-data
- lib/pattern_analyzer.ex: analyzes scans and generates summaries
- prolog/pattern_detection.lgt: Logtalk rules for pattern detection

Implements Task 4 from verisimdb/SONNET-TASKS.md.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Jonathan D.A. Jewell

lib/pattern_analyzer.ex

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+
+defmodule Hypatia.PatternAnalyzer do
+  @moduledoc """
+  Analyzes scan results from verisimdb and detects patterns.
+  """
+
+  alias Hypatia.VerisimdbConnector
+
+  require Logger
+
+  def analyze_all_scans do
+    scans = VerisimdbConnector.fetch_all_scans()
+
+    Logger.info("Loaded #{length(scans)} scan results")
+
+    # Write facts to temp file
+    facts = Enum.map_join(scans, "\n", &VerisimdbConnector.to_logtalk_facts/1)
+    facts_file = "/tmp/scan_facts.lgt"
+    File.write!(facts_file, facts)
+
+    Logger.info("Wrote Logtalk facts to #{facts_file}")
+
+    # TODO: Integrate with actual Logtalk interpreter
+    # For now, just return the scans
+    {:ok, %{
+      scan_count: length(scans),
+      facts_file: facts_file,
+      scans: scans
+    }}
+  end
+
+  def generate_summary(scans) do
+    total_weak_points =
+      scans
+      |> Enum.map(fn scan ->
+        Map.get(scan.scan, "weak_points", []) |> length()
+      end)
+      |> Enum.sum()
+
+    repos_by_severity =
+      scans
+      |> Enum.map(fn scan ->
+        summary = Map.get(scan.scan, "summary", %{})
+        {scan.repo, summary}
+      end)
+      |> Enum.into(%{})
+
+    %{
+      total_repos: length(scans),
+      total_weak_points: total_weak_points,
+      repos_by_severity: repos_by_severity
+    }
+  end
+end

lib/verisimdb_connector.ex

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+
+defmodule Hypatia.VerisimdbConnector do
+  @moduledoc """
+  Reads scan results from verisimdb-data repo and transforms into Logtalk facts.
+  """
+
+  @verisimdb_data_path "~/Documents/hyperpolymath-repos/verisimdb-data"
+
+  def fetch_all_scans do
+    scans_path = Path.join(expand_path(@verisimdb_data_path), "scans")
+
+    case File.ls(scans_path) do
+      {:ok, files} ->
+        files
+        |> Enum.filter(&String.ends_with?(&1, ".json"))
+        |> Enum.map(&load_scan/1)
+        |> Enum.reject(&is_nil/1)
+
+      {:error, reason} ->
+        require Logger
+        Logger.error("Failed to read scans directory: #{inspect(reason)}")
+        []
+    end
+  end
+
+  defp load_scan(filename) do
+    path = Path.join([expand_path(@verisimdb_data_path), "scans", filename])
+    repo_name = String.replace(filename, ".json", "")
+
+    with {:ok, content} <- File.read(path),
+         {:ok, data} <- Jason.decode(content) do
+      %{repo: repo_name, scan: data}
+    else
+      {:error, reason} ->
+        require Logger
+        Logger.error("Failed to load scan #{filename}: #{inspect(reason)}")
+        nil
+    end
+  end
+
+  def to_logtalk_facts(scan_data) do
+    # Transform weak points into Logtalk facts
+    weak_points = Map.get(scan_data.scan, "weak_points", [])
+
+    weak_points
+    |> Enum.map(fn wp ->
+      file = Map.get(wp, "file", "unknown")
+      category = Map.get(wp, "category", "unknown")
+      severity = Map.get(wp, "severity", "unknown")
+
+      """
+      weak_point('#{scan_data.repo}', '#{file}', '#{category}', '#{severity}').
+      """
+    end)
+    |> Enum.join("\n")
+  end
+
+  defp expand_path(path) do
+    Path.expand(path)
+  end
+end

prolog/pattern_detection.lgt

@@ -0,0 +1,46 @@
+% SPDX-License-Identifier: PMPL-1.0-or-later
+
+% Pattern detection rules for scan results
+
+:- object(pattern_detector).
+
+    % Detect widespread unsafe pattern
+    :- public(widespread_unsafe/2).
+    widespread_unsafe(Pattern, Repos) :-
+        findall(Repo, weak_point(Repo, _, Pattern, high), Repos),
+        length(Repos, Count),
+        Count >= 3.
+
+    % Detect deteriorating repo
+    :- public(deteriorating/1).
+    deteriorating(Repo) :-
+        % TODO: Compare current vs previous scan
+        % Needs temporal data
+        fail.
+
+    % Detect critical weak points in a repo
+    :- public(critical_weak_points/2).
+    critical_weak_points(Repo, Count) :-
+        findall(1, weak_point(Repo, _, _, critical), List),
+        length(List, Count),
+        Count > 0.
+
+    % Find all repos with a specific weakness type
+    :- public(repos_with_weakness/2).
+    repos_with_weakness(WeaknessType, Repos) :-
+        findall(Repo, weak_point(Repo, _, WeaknessType, _), RepoList),
+        list::unique(RepoList, Repos).
+
+    % Calculate risk score for a repo
+    :- public(repo_risk_score/2).
+    repo_risk_score(Repo, Score) :-
+        findall(S, (weak_point(Repo, _, _, Severity), severity_score(Severity, S)), Scores),
+        list::sum(Scores, Score).
+
+    % Helper: severity to numeric score
+    severity_score(critical, 10).
+    severity_score(high, 5).
+    severity_score(medium, 2).
+    severity_score(low, 1).
+
+:- end_object.