nerima 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1463ee71dbe01193461cb0c748a2d58d26dfd435a950edf1d943bd9591d2c8b3
+  data.tar.gz: 01321c4e553823f4116aa49b840dc1769cdfc7a2007fba87b19b9a4602c153c7
+SHA512:
+  metadata.gz: 26531a5db88201918c1c6e9b0839c9ea46416c5e4ca689cd6a59b2bfe5723389dfeac8f3a22d7b4789a0b853df398220725cf2543344c693874fdca3d2066f4f
+  data.tar.gz: 53b125cf78c956aada5ea5f0676915a2342ef0debd1c80a76a362e26a55afef5814124a688afbb08f187ebc076d581354c1948810218e13687bb649f7fe48023

data/exe/nerima

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "seo/cli"
+
+Seo::CLI::App.start(ARGV)

data/lib/seo/analyser.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "result"
+
+module Seo
+  class Analyser
+    def initialize(provider:)
+      @provider = provider
+    end
+
+    MAX_CONCURRENT = 5
+
+    def analyse(files, &on_result)
+      results = Array.new(files.length)
+      queue = Queue.new
+      files.each_with_index { |f, i| queue << [f, i] }
+      mutex = Mutex.new
+
+      [files.length, MAX_CONCURRENT].min.times.map do
+        Thread.new do
+          while (job = begin; queue.pop(true); rescue ThreadError; nil; end)
+            file, i = job
+            begin
+              content = File.read(file)
+              result = analyse_file(file, content)
+            rescue => e
+              result = Result.new(
+                file: file,
+                issues: [{ severity: :critical, check: "internal", message: "Could not read file: #{e.message}", line: nil }],
+                suggestions: [],
+                fixed_content: nil
+              )
+            end
+            mutex.synchronize do
+              results[i] = result
+              on_result&.call(result)
+            end
+          end
+        end
+      end.each(&:join)
+
+      results
+    end
+
+    # Called only by `seo fix` — separate API call, higher token budget
+    def fix(file)
+      content = File.read(file)
+      fixed = call_api(build_fix_prompt(file, content), max_tokens: 4096)
+      result = analyse_file(file, content)
+      Result.new(
+        file: result.file,
+        issues: result.issues,
+        suggestions: result.suggestions,
+        fixed_content: fixed.strip != content.strip ? fixed : nil
+      )
+    end
+
+    private
+
+    def analyse_file(file, content)
+      raw = call_api(build_prompt(file, content), max_tokens: 2048)
+      parse_response(file, raw)
+    end
+
+    def call_api(prompt, max_tokens:)
+      @provider.complete(prompt, max_tokens: max_tokens)
+    end
+
+    def build_prompt(file, content)
+      <<~PROMPT
+        You are an SEO expert analysing a web template file. Analyse the following file for SEO issues.
+
+        File: #{file}
+        Template type: #{detect_template_type(file)}
+
+        ```
+        #{content.slice(0, 8000)}
+        ```
+
+        Return ONLY a raw JSON object — no markdown, no code fences, no explanation before or after. Use this exact structure:
+        {"issues":[{"severity":"critical","check":"meta","message":"description","line":null}],"suggestions":["suggestion"],"ai_risk":"none","ai_risk_reason":"reason"}
+
+        severity: "critical" or "warning"
+        check: one of meta, headings, images, links, canonical, opengraph, schema, content
+        ai_risk: "none", "low", "medium", or "high"
+
+        Check for:
+        - Meta title: present, 50-60 chars, contains primary keyword
+        - Meta description: present, 150-160 chars, compelling
+        - Heading hierarchy: single H1, logical H2/H3 structure, no skipped levels
+        - Images: all have descriptive alt text
+        - Canonical tag present
+        - Open Graph tags: og:title, og:description, og:image
+        - Schema/structured data present
+        - Content: thin content, keyword usage, internal linking
+        - AI risk: is this content likely to be replaced by Google AI overviews?
+      PROMPT
+    end
+
+    def build_fix_prompt(file, content)
+      <<~PROMPT
+        You are an SEO expert. Return an improved version of the following web template file.
+
+        File: #{file}
+        Template type: #{detect_template_type(file)}
+
+        ```
+        #{content}
+        ```
+
+        Return ONLY the corrected file content — no explanation, no markdown fences. Improve: meta tags, alt text, heading structure, canonical tags, Open Graph tags, structured data. Do not rewrite body copy or change layout.
+      PROMPT
+    end
+
+    def detect_template_type(file)
+      case File.extname(file)
+      when ".erb"              then "ERB (Ruby)"
+      when ".haml"             then "Haml"
+      when ".slim"             then "Slim"
+      when ".jinja", ".jinja2" then "Jinja2 (Python)"
+      when ".twig"             then "Twig (PHP)"
+      when ".njk"              then "Nunjucks (JS)"
+      when ".html"             then "HTML"
+      else "Unknown"
+      end
+    end
+
+    def parse_response(file, raw)
+      start_idx = raw.index("{")
+      end_idx   = raw.rindex("}")
+      json_str  = (start_idx && end_idx) ? raw[start_idx..end_idx] : raw
+      data      = JSON.parse(json_str)
+
+      issues = (data["issues"] || []).map do |i|
+        {
+          severity:       i["severity"].to_sym,
+          check:          i["check"],
+          message:        i["message"],
+          line:           i["line"],
+          ai_risk:        data["ai_risk"],
+          ai_risk_reason: data["ai_risk_reason"]
+        }
+      end
+
+      Result.new(
+        file:          file,
+        issues:        issues,
+        suggestions:   data["suggestions"] || [],
+        fixed_content: nil
+      )
+    rescue JSON::ParserError
+      Result.new(
+        file:          file,
+        issues:        [{ severity: :warning, check: "internal", message: "Could not parse AI response", line: nil }],
+        suggestions:   [],
+        fixed_content: nil
+      )
+    end
+  end
+end

data/lib/seo/cli/config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Seo
+  module CLI
+    module Config
+      CONFIG_FILE = ".seo.yml"
+
+      DEFAULTS = {
+        "include" => [
+          "**/*.html.erb",
+          "**/*.html.haml",
+          "**/*.html.slim",
+          "**/*.html",
+          "**/*.jinja",
+          "**/*.jinja2",
+          "**/*.twig",
+          "**/*.blade.php",
+          "**/*.njk"
+        ],
+        "exclude" => [
+          "vendor/**",
+          "node_modules/**",
+          "tmp/**",
+          ".git/**"
+        ],
+        "checks"   => %w[meta headings images links canonical opengraph schema],
+        "provider" => "anthropic",
+        "api_key"  => nil
+      }.freeze
+
+      def self.load
+        if File.exist?(CONFIG_FILE)
+          DEFAULTS.merge(YAML.safe_load_file(CONFIG_FILE) || {})
+        else
+          DEFAULTS
+        end
+      end
+
+      def self.write_default
+        File.write(CONFIG_FILE, YAML.dump(DEFAULTS))
+      end
+    end
+  end
+end

data/lib/seo/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Seo
+  module Cli
+    VERSION = "0.1.0"
+  end
+end

data/lib/seo/cli.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require "pastel"
+require "tty-prompt"
+
+require_relative "cli/version"
+require_relative "cli/config"
+require_relative "scanner"
+require_relative "analyser"
+require_relative "providers"
+require_relative "output/terminal"
+require_relative "output/reporter"
+
+module Seo
+  module CLI
+    LOGO = <<~LOGO
+       _  _ ___ ___ ___ __  __   _
+      | \\| | __| _ \\_ _|  \\/  | /_\\
+      | .` | _||   /| || |\\/| |/ _ \\
+      |_|\\_|___|_|_\\___|_|  |_/_/ \\_\\
+    LOGO
+
+    class App < Thor
+      def self.start(args = ARGV, **opts)
+        pastel = Pastel.new
+        $stdout.puts pastel.bright_magenta(LOGO)
+        $stdout.puts pastel.bright_magenta("  AI-powered SEO analysis") + "\n\n"
+        super
+      end
+
+      class_option :provider, type: :string, desc: "AI provider: anthropic, openai, gemini, ollama (overrides .seo.yml)"
+      class_option :key,      type: :string, desc: "API key for the selected provider (overrides .seo.yml and env vars)"
+      class_option :model,    type: :string, desc: "Model name to use (overrides provider default)"
+
+      desc "check [FILE]", "Analyse a file or entire project for SEO issues"
+      option :format, type: :string, default: "terminal", enum: %w[terminal json html], desc: "Output format"
+      def check(file = nil)
+        files = file ? [file] : Scanner.new(config).scan
+        if files.empty?
+          puts pastel.yellow("No template files found. Check your .seo.yml config.")
+          return
+        end
+
+        puts pastel.cyan("Analysing #{files.length} file(s)...")
+
+        if options[:format] == "terminal"
+          terminal = Output::Terminal.new
+          results = Analyser.new(provider: provider).analyse(files) { |r| terminal.render_result(r) }
+          terminal.render_summary(results)
+        else
+          results = Analyser.new(provider: provider).analyse(files)
+          puts Output::Reporter.new.render(results, format: options[:format])
+        end
+      end
+
+      desc "fix FILE", "Show a diff of suggested SEO fixes for a file and optionally apply them"
+      def fix(file)
+        abort(pastel.red("File not found: #{file}")) unless File.exist?(file)
+
+        puts pastel.cyan("Analysing #{file}...")
+        result = Analyser.new(provider: provider).fix(file)
+
+        unless result&.fixed_content
+          puts pastel.green("No fixes suggested for #{file}")
+          return
+        end
+
+        Output::Terminal.new.render_diff(result)
+
+        prompt = TTY::Prompt.new
+        if prompt.yes?("Apply these changes to #{file}?")
+          File.write(file, result.fixed_content)
+          puts pastel.green("✓ Changes applied to #{file}")
+        else
+          puts pastel.yellow("Changes not applied.")
+        end
+      end
+
+      desc "report", "Generate a full SEO report for the project"
+      option :format, type: :string, default: "terminal", enum: %w[terminal json html pdf], desc: "Output format"
+      option :output, type: :string, desc: "Write report to file (e.g. seo-report.html or seo-report.pdf)"
+      def report
+        files = Scanner.new(config).scan
+        if files.empty?
+          puts pastel.yellow("No template files found.")
+          return
+        end
+
+        if options[:format] == "pdf" && options[:output].nil?
+          abort pastel.red("--output is required for PDF format. Example: nerima report --format pdf --output seo-report.pdf")
+        end
+
+        puts pastel.cyan("Scanning #{files.length} files...")
+        done = 0
+        results = Analyser.new(provider: provider).analyse(files) do |r|
+          done += 1
+          puts pastel.dim("  [#{done}/#{files.length}] #{File.basename(r.file)}")
+        end
+        Output::Terminal.new.render_summary(results)
+
+        if options[:output]
+          if options[:format] == "pdf"
+            Output::Reporter.new.render_pdf(results, output_path: options[:output])
+          else
+            fmt = options[:format] == "terminal" ? "html" : options[:format]
+            File.write(options[:output], Output::Reporter.new.render(results, format: fmt))
+          end
+          puts pastel.green("✓ Report written to #{options[:output]}")
+        end
+      end
+
+      desc "init", "Create a .seo.yml config file in the current directory"
+      def init
+        if File.exist?(".seo.yml")
+          puts pastel.yellow(".seo.yml already exists.")
+          return
+        end
+        Seo::CLI::Config.write_default
+        puts pastel.green("✓ Created .seo.yml — edit it to configure which files to scan.")
+      end
+
+      private
+
+      def provider
+        provider_name = options[:provider] || config["provider"] || "anthropic"
+        api_key = options[:key] || env_key_for(provider_name) || config["api_key"] ||
+          config["anthropic_api_key"] # backward compat
+
+        if api_key.nil? && provider_name != "ollama"
+          abort pastel.red("No API key found for '#{provider_name}'. Set --key, the relevant env var, or add api_key to .seo.yml")
+        end
+
+        Providers.build(
+          provider_name: provider_name,
+          api_key:       api_key,
+          model:         options[:model] || config["model"]
+        )
+      rescue ArgumentError => e
+        abort pastel.red(e.message)
+      end
+
+      def env_key_for(provider_name)
+        env_var = {
+          "anthropic" => "ANTHROPIC_API_KEY",
+          "openai"    => "OPENAI_API_KEY",
+          "gemini"    => "GEMINI_API_KEY"
+        }[provider_name.to_s]
+        ENV[env_var] if env_var
+      end
+
+      def config
+        @config ||= Seo::CLI::Config.load
+      end
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
+    end
+  end
+end

data/lib/seo/output/reporter.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "prawn"
+require "prawn/table"
+
+module Seo
+  module Output
+    class Reporter
+      INDIGO  = "4f46e5"
+      RED     = "dc2626"
+      AMBER   = "d97706"
+      GREEN   = "16a34a"
+      SLATE   = "475569"
+      LIGHT   = "f1f5f9"
+      WHITE   = "ffffff"
+
+      def render(results, format:)
+        case format.to_s
+        when "json" then render_json(results)
+        when "html" then render_html(results)
+        else raise ArgumentError, "Unknown format: #{format}"
+        end
+      end
+
+      def render_pdf(results, output_path:)
+        avg_score     = results.sum(&:score) / [results.length, 1].max
+        total_issues  = results.sum { |r| r.issues.length }
+        clean_count   = results.count { |r| r.issues.empty? }
+
+        Prawn::Document.generate(output_path, page_size: "A4", margin: [36, 40, 36, 40]) do |pdf|
+          # ── Header ───────────────────────────────────────────────────────
+          pdf.fill_color INDIGO
+          pdf.fill_rectangle [pdf.bounds.left, pdf.bounds.top + 36], pdf.bounds.width + 80, 70
+          pdf.fill_color WHITE
+          pdf.move_to [pdf.bounds.left, pdf.bounds.top + 20]
+          pdf.font_size(18) { pdf.text "SEO Report", style: :bold }
+          pdf.font_size(9)  { pdf.text "Generated #{Time.now.strftime("%d %b %Y %H:%M")}  ·  #{results.length} files scanned", color: "c7d2fe" }
+          pdf.move_down 20
+
+          # ── Summary cards ────────────────────────────────────────────────
+          pdf.fill_color "000000"
+          summary_data = [
+            ["Average Score", "#{avg_score}/100", score_color(avg_score)],
+            ["Total Issues",  total_issues.to_s,  total_issues.zero? ? GREEN : RED],
+            ["Clean Files",   "#{clean_count}/#{results.length}", clean_count == results.length ? GREEN : AMBER]
+          ]
+
+          card_width  = (pdf.bounds.width - 20) / 3.0
+          card_height = 52
+
+          summary_data.each_with_index do |(label, value, color), i|
+            x = pdf.bounds.left + i * (card_width + 10)
+            y = pdf.cursor
+
+            pdf.fill_color LIGHT
+            pdf.fill_rounded_rectangle [x, y], card_width, card_height, 4
+            pdf.fill_color "94a3b8"
+            pdf.font_size(7) { pdf.draw_text label.upcase, at: [x + 10, y - 14] }
+            pdf.fill_color color
+            pdf.font_size(20) { pdf.draw_text value, at: [x + 10, y - 38], style: :bold }
+          end
+
+          pdf.move_down card_height + 16
+
+          # ── File results ─────────────────────────────────────────────────
+          results.each do |result|
+            pdf.fill_color "000000"
+
+            # Card background
+            card_start_y = pdf.cursor
+            pdf.fill_color LIGHT
+            pdf.fill_rounded_rectangle [pdf.bounds.left, card_start_y], pdf.bounds.width, 10, 4
+
+            # File name
+            pdf.fill_color INDIGO
+            pdf.font_size(8) { pdf.font("Courier") { pdf.text result.file, style: :bold } }
+            pdf.move_down 4
+
+            if result.issues.empty?
+              pdf.fill_color GREEN
+              pdf.font_size(9) { pdf.text "✓ No issues found" }
+            else
+              result.issues.each do |issue|
+                sev_color = issue[:severity] == :critical ? RED : AMBER
+                pdf.fill_color sev_color
+                pdf.font_size(7.5) do
+                  pdf.text "[#{issue[:severity].to_s.upcase}] [#{issue[:check]}]  #{issue[:message]}", indent_paragraphs: 8
+                end
+
+                if issue[:ai_risk] && issue[:ai_risk] != "none"
+                  risk_color = { "high" => RED, "medium" => AMBER, "low" => GREEN }.fetch(issue[:ai_risk], SLATE)
+                  pdf.fill_color risk_color
+                  pdf.font_size(7) { pdf.text "  AI Overview risk: #{issue[:ai_risk].upcase}", indent_paragraphs: 16 }
+                end
+              end
+
+              unless result.suggestions.empty?
+                pdf.move_down 3
+                pdf.fill_color SLATE
+                result.suggestions.each do |s|
+                  pdf.font_size(7.5) { pdf.text "• #{s}", indent_paragraphs: 8 }
+                end
+              end
+            end
+
+            # Score
+            pdf.move_down 4
+            pdf.fill_color "94a3b8"
+            pdf.font_size(7) { pdf.text "Score: #{result.score}/100", align: :right, color: score_color(result.score) }
+            pdf.move_down 10
+
+            # Stretch card bg to actual height
+            card_height_actual = card_start_y - pdf.cursor
+            pdf.fill_color LIGHT
+            pdf.fill_rounded_rectangle [pdf.bounds.left, card_start_y], pdf.bounds.width, card_height_actual, 4
+            pdf.move_down 8
+
+            pdf.start_new_page if pdf.cursor < 80
+          end
+        end
+      end
+
+      private
+
+      def render_json(results)
+        JSON.pretty_generate(results.map(&:to_h))
+      end
+
+      def render_html(results)
+        avg_score = results.sum(&:score) / [results.length, 1].max
+        total_issues = results.sum { |r| r.issues.length }
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>SEO Report</title>
+            <style>
+              * { box-sizing: border-box; margin: 0; padding: 0; }
+              body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f8fafc; color: #1e293b; }
+              .header { background: #4f46e5; color: white; padding: 2rem; }
+              .header h1 { font-size: 1.5rem; font-weight: 700; }
+              .header p { opacity: 0.8; margin-top: 0.25rem; font-size: 0.875rem; }
+              .summary { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1rem; padding: 1.5rem; }
+              .card { background: white; border-radius: 0.75rem; padding: 1.25rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+              .card .label { font-size: 0.75rem; text-transform: uppercase; color: #94a3b8; font-weight: 600; }
+              .card .value { font-size: 2rem; font-weight: 700; margin-top: 0.25rem; }
+              .score-high { color: #16a34a; }
+              .score-mid  { color: #d97706; }
+              .score-low  { color: #dc2626; }
+              .files { padding: 0 1.5rem 1.5rem; display: grid; gap: 1rem; }
+              .file-card { background: white; border-radius: 0.75rem; padding: 1.25rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+              .file-name { font-weight: 600; font-family: monospace; font-size: 0.875rem; margin-bottom: 0.75rem; }
+              .issue { display: flex; gap: 0.5rem; align-items: flex-start; padding: 0.4rem 0; font-size: 0.875rem; border-bottom: 1px solid #f1f5f9; }
+              .issue:last-child { border-bottom: none; }
+              .badge { font-size: 0.65rem; font-weight: 700; padding: 0.15rem 0.4rem; border-radius: 9999px; white-space: nowrap; }
+              .critical { background: #fee2e2; color: #dc2626; }
+              .warning  { background: #fef3c7; color: #d97706; }
+              .check-badge { background: #e0e7ff; color: #4f46e5; }
+              .suggestions { margin-top: 0.75rem; padding-top: 0.75rem; border-top: 1px solid #f1f5f9; }
+              .suggestions li { font-size: 0.8125rem; color: #475569; padding: 0.2rem 0 0.2rem 1rem; list-style: disc; }
+              .ai-risk { display: inline-flex; align-items: center; gap: 0.4rem; font-size: 0.75rem; font-weight: 600; margin-top: 0.5rem; }
+              .risk-high   { color: #dc2626; }
+              .risk-medium { color: #d97706; }
+              .risk-low    { color: #16a34a; }
+              .clean { color: #16a34a; font-size: 0.875rem; }
+            </style>
+          </head>
+          <body>
+            <div class="header">
+              <h1>SEO Report</h1>
+              <p>Generated #{Time.now.strftime("%d %b %Y %H:%M")} · #{results.length} files scanned</p>
+            </div>
+
+            <div class="summary">
+              <div class="card">
+                <div class="label">Average Score</div>
+                <div class="value #{score_class(avg_score)}">#{avg_score}/100</div>
+              </div>
+              <div class="card">
+                <div class="label">Total Issues</div>
+                <div class="value #{total_issues.zero? ? "score-high" : "score-low"}">#{total_issues}</div>
+              </div>
+              <div class="card">
+                <div class="label">Files Scanned</div>
+                <div class="value">#{results.length}</div>
+              </div>
+            </div>
+
+            <div class="files">
+              #{results.map { |r| file_card(r) }.join("\n")}
+            </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      def file_card(result)
+        issues_html = if result.issues.empty?
+          '<p class="clean">✓ No issues found</p>'
+        else
+          result.issues.map do |i|
+            ai_note = ""
+            if i[:ai_risk] && i[:ai_risk] != "none"
+              ai_note = "<div class=\"ai-risk risk-#{i[:ai_risk]}\">AI Overview risk: #{i[:ai_risk].upcase}</div>"
+            end
+            "<div class=\"issue\"><span class=\"badge #{i[:severity]}\">#{i[:severity]}</span><span class=\"badge check-badge\">#{i[:check]}</span><span>#{i[:message]}</span>#{ai_note}</div>"
+          end.join
+        end
+
+        suggestions_html = unless result.suggestions.empty?
+          "<div class=\"suggestions\"><ul>#{result.suggestions.map { |s| "<li>#{s}</li>" }.join}</ul></div>"
+        end
+
+        score_html = "<div style='text-align:right;font-size:0.75rem;color:#94a3b8;margin-top:0.5rem;'>Score: <strong class='#{score_class(result.score)}'>#{result.score}/100</strong></div>"
+
+        "<div class=\"file-card\"><div class=\"file-name\">#{result.file}</div>#{issues_html}#{suggestions_html}#{score_html}</div>"
+      end
+
+      def score_class(score)
+        score >= 80 ? "score-high" : score >= 50 ? "score-mid" : "score-low"
+      end
+
+      def score_color(score)
+        score >= 80 ? GREEN : score >= 50 ? AMBER : RED
+      end
+    end
+  end
+end

data/lib/seo/output/terminal.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "diffy"
+
+module Seo
+  module Output
+    class Terminal
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      def render(results)
+        results.each { |r| render_result(r) }
+        render_summary(results)
+      end
+
+      def render_result(result)
+        puts ""
+        puts @pastel.bold(result.file)
+        puts @pastel.dim("─" * 60)
+
+        if result.issues.empty?
+          puts @pastel.green("  ✓ No issues found")
+        else
+          result.critical.each do |issue|
+            line_ref = issue[:line] ? @pastel.dim(" (line #{issue[:line]})") : ""
+            puts "  #{@pastel.red("✖")} #{@pastel.bold("[#{issue[:check]}]")} #{issue[:message]}#{line_ref}"
+          end
+          result.warnings.each do |issue|
+            line_ref = issue[:line] ? @pastel.dim(" (line #{issue[:line]})") : ""
+            puts "  #{@pastel.yellow("⚠")} #{@pastel.bold("[#{issue[:check]}]")} #{issue[:message]}#{line_ref}"
+          end
+        end
+
+        if result.issues.any? && result.issues.first[:ai_risk] && result.issues.first[:ai_risk] != "none"
+          risk = result.issues.first[:ai_risk]
+          colour = { "low" => :green, "medium" => :yellow, "high" => :red }.fetch(risk, :white)
+          puts ""
+          puts "  #{@pastel.bold("AI Overview risk:")} #{@pastel.send(colour, risk.upcase)}"
+          puts @pastel.dim("  #{result.issues.first[:ai_risk_reason]}")
+        end
+
+        unless result.suggestions.empty?
+          puts ""
+          puts @pastel.cyan("  Suggestions:")
+          result.suggestions.each { |s| puts "  • #{s}" }
+        end
+
+        puts "  #{@pastel.dim("Score:")} #{score_colour(result.score)}"
+      end
+
+      def render_diff(result)
+        puts ""
+        puts @pastel.bold("Suggested changes for #{result.file}:")
+        puts ""
+
+        diff = Diffy::Diff.new(
+          File.read(result.file),
+          result.fixed_content,
+          context: 3
+        )
+
+        diff.each_chunk do |chunk|
+          chunk.each_line do |line|
+            case line[0]
+            when "+"
+              print @pastel.green(line)
+            when "-"
+              print @pastel.red(line)
+            else
+              print @pastel.dim(line)
+            end
+          end
+        end
+        puts ""
+      end
+
+      def render_summary(results)
+        total   = results.length
+        clean   = results.count { |r| r.issues.empty? }
+        issues  = results.sum { |r| r.issues.length }
+        avg     = results.sum(&:score) / [total, 1].max
+
+        puts ""
+        puts @pastel.bold("─" * 60)
+        puts @pastel.bold("Summary")
+        puts "  Files scanned:  #{total}"
+        puts "  Clean files:    #{@pastel.green(clean.to_s)}"
+        puts "  Total issues:   #{issues.positive? ? @pastel.red(issues.to_s) : @pastel.green("0")}"
+        puts "  Average score:  #{score_colour(avg)}"
+
+        high_risk = results.select { |r| r.issues.any? { |i| i[:ai_risk] == "high" } }
+        unless high_risk.empty?
+          puts ""
+          puts @pastel.red("  High AI Overview risk (#{high_risk.length} files):")
+          high_risk.each { |r| puts "    • #{r.file}" }
+        end
+        puts ""
+      end
+
+      private
+
+      def score_colour(score)
+        colour = score >= 80 ? :green : score >= 50 ? :yellow : :red
+        @pastel.send(colour, "#{score}/100")
+      end
+    end
+  end
+end

data/lib/seo/providers/anthropic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "anthropic"
+require_relative "base"
+
+module Seo
+  module Providers
+    class Anthropic < Base
+      DEFAULT_MODEL = "claude-sonnet-4-6"
+
+      def initialize(api_key:, model: DEFAULT_MODEL)
+        @client = ::Anthropic::Client.new(access_token: api_key)
+        @model  = model
+      end
+
+      def complete(prompt, max_tokens:)
+        response = @client.messages(parameters: {
+          model:      @model,
+          max_tokens: max_tokens,
+          messages:   [{ role: "user", content: prompt }]
+        })
+        response.dig("content", 0, "text").to_s
+      end
+    end
+  end
+end

data/lib/seo/providers/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Seo
+  module Providers
+    class Base
+      def complete(prompt, max_tokens:)
+        raise NotImplementedError, "#{self.class} must implement #complete"
+      end
+    end
+  end
+end

data/lib/seo/providers/gemini.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "base"
+
+module Seo
+  module Providers
+    class Gemini < Base
+      DEFAULT_MODEL = "gemini-1.5-pro"
+      BASE_URL      = "https://generativelanguage.googleapis.com/v1beta/models"
+
+      def initialize(api_key:, model: DEFAULT_MODEL)
+        @api_key = api_key
+        @model   = model
+      end
+
+      def complete(prompt, max_tokens:)
+        uri  = URI("#{BASE_URL}/#{@model}:generateContent?key=#{@api_key}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate({
+          contents:       [{ parts: [{ text: prompt }] }],
+          generationConfig: { maxOutputTokens: max_tokens }
+        })
+
+        data = JSON.parse(http.request(req).body)
+        data.dig("candidates", 0, "content", "parts", 0, "text").to_s
+      end
+    end
+  end
+end

data/lib/seo/providers/ollama.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "base"
+
+module Seo
+  module Providers
+    class Ollama < Base
+      DEFAULT_MODEL = "llama3"
+      DEFAULT_HOST  = "http://localhost:11434"
+
+      def initialize(api_key: nil, model: DEFAULT_MODEL, host: DEFAULT_HOST)
+        @model = model
+        @host  = host
+      end
+
+      def complete(prompt, max_tokens:)
+        uri  = URI("#{@host}/api/chat")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate({
+          model:    @model,
+          stream:   false,
+          messages: [{ role: "user", content: prompt }]
+        })
+
+        data = JSON.parse(http.request(req).body)
+        data.dig("message", "content").to_s
+      end
+    end
+  end
+end

data/lib/seo/providers/openai.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "base"
+
+module Seo
+  module Providers
+    class OpenAI < Base
+      DEFAULT_MODEL = "gpt-4o"
+      API_URL       = "https://api.openai.com/v1/chat/completions"
+
+      def initialize(api_key:, model: DEFAULT_MODEL)
+        @api_key = api_key
+        @model   = model
+      end
+
+      def complete(prompt, max_tokens:)
+        uri  = URI(API_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Bearer #{@api_key}"
+        req["Content-Type"]  = "application/json"
+        req.body = JSON.generate({
+          model:      @model,
+          max_tokens: max_tokens,
+          messages:   [{ role: "user", content: prompt }]
+        })
+
+        data = JSON.parse(http.request(req).body)
+        data.dig("choices", 0, "message", "content").to_s
+      end
+    end
+  end
+end

data/lib/seo/providers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "providers/base"
+require_relative "providers/anthropic"
+require_relative "providers/openai"
+require_relative "providers/gemini"
+require_relative "providers/ollama"
+
+module Seo
+  module Providers
+    REGISTRY = {
+      "anthropic" => Anthropic,
+      "openai"    => OpenAI,
+      "gemini"    => Gemini,
+      "ollama"    => Ollama
+    }.freeze
+
+    def self.build(provider_name:, api_key: nil, model: nil, host: nil)
+      klass = REGISTRY[provider_name.to_s.downcase]
+      raise ArgumentError, "Unknown provider '#{provider_name}'. Supported: #{REGISTRY.keys.join(", ")}" unless klass
+
+      args = { api_key: api_key }
+      args[:model] = model if model
+      args[:host]  = host  if host && provider_name.to_s == "ollama"
+      klass.new(**args)
+    end
+
+    def self.names
+      REGISTRY.keys
+    end
+  end
+end

data/lib/seo/result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Seo
+  Result = Struct.new(:file, :issues, :suggestions, :fixed_content, keyword_init: true) do
+    def score
+      return 100 if issues.empty?
+      [100 - (issues.length * 10), 0].max
+    end
+
+    def critical
+      issues.select { |i| i[:severity] == :critical }
+    end
+
+    def warnings
+      issues.select { |i| i[:severity] == :warning }
+    end
+
+    def to_h
+      {
+        file: file,
+        score: score,
+        issues: issues,
+        suggestions: suggestions
+      }
+    end
+  end
+end

data/lib/seo/scanner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Seo
+  class Scanner
+    def initialize(config)
+      @include_patterns = config["include"] || []
+      @exclude_patterns = config["exclude"] || []
+    end
+
+    def scan(root = Dir.pwd)
+      files = @include_patterns.flat_map do |pattern|
+        Dir.glob(File.join(root, pattern))
+      end.uniq.sort
+
+      files.reject do |file|
+        @exclude_patterns.any? do |pattern|
+          File.fnmatch?(File.join(root, pattern), file, File::FNM_PATHNAME)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: nerima
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Dringer
+bindir: exe
+cert_chain: []
+date: 2026-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: ruby-anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: tty-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: prawn-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: AI-powered SEO analysis for developers. Scan your templates, spot issues,
+  and fix them — without ever leaving your terminal.
+executables:
+- nerima
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/nerima
+- lib/seo/analyser.rb
+- lib/seo/cli.rb
+- lib/seo/cli/config.rb
+- lib/seo/cli/version.rb
+- lib/seo/output/reporter.rb
+- lib/seo/output/terminal.rb
+- lib/seo/providers.rb
+- lib/seo/providers/anthropic.rb
+- lib/seo/providers/base.rb
+- lib/seo/providers/gemini.rb
+- lib/seo/providers/ollama.rb
+- lib/seo/providers/openai.rb
+- lib/seo/result.rb
+- lib/seo/scanner.rb
+homepage: https://nerimasoft.co.uk/nerima.html
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: AI-powered SEO analysis for developers
+test_files: []