Extensible catalogs, Humanize diff, and shareable card

The "plus": make detection extensible + two demo money-shots.

- Extensible catalogs: RulePack is now composable — Analyze(text, lang, extraPacks)
  merges custom rule-packs on top of built-ins (override by id). RulePack.FromJson/
  ToJson/Merge. Web: a "Custom catalogs" panel — quick-add banned words or import a
  rule-pack JSON, stored in localStorage, applied live; export the EN pack as a
  template. CLI: --rules <file.json> (repeatable). 4 new Core tests (19 total).
- Humanize before/after: word-level WordDiff (LCS) shown side-by-side (removed red /
  added green) with the AI score dropping before → after.
- Shareable card: JS canvas renderer (score ring, category pills, sentence-rhythm
  sparkline, PeopleWorks branding) → downloadable PNG. Privacy-preserving (summary
  only, never the text).

All verified in-browser. Build clean, 19/19 tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: peopleworks

README.md

@@ -48,6 +48,14 @@ an original derivation of AI-writing markers for Spanish.
 
   Credentials are stored only in your browser and sent **directly** to the provider — never to us
   (there is no backend).
+- **Custom catalogs (bring your own)** — extend the detector with your own rules: paste your team's
+  banned words for an instant catalog, or import a full rule-pack JSON. Catalogs are stored only in
+  your browser, merge on top of the built-in packs (overriding by rule id), and apply **live**. The
+  CLI takes them too: `signsofai check post.md --rules my-style.json`.
+- **Before/after diff** — after Humanize, see a word-level diff (removed in red, added in green) and
+  the AI score dropping from before → after.
+- **Shareable result card** — one click renders a clean PNG summary card (score, categories, sentence
+  rhythm, branding) you can post — privacy-preserving, it never includes your text.
 - **Catalog** — a searchable library of every AI-writing sign the analyzer knows, in both languages,
   with explanations and fixes. Ranked with an in-browser BM25 index. A study aid for students.
 

src/SignsOfAI.Cli/Program.cs

@@ -2,6 +2,7 @@
 using SignsOfAI.Core;
 using SignsOfAI.Core.Documents;
 using SignsOfAI.Core.Model;
+using SignsOfAI.Core.Rules;
 
 // ── signsofai: lint prose for the signs of AI writing ────────────────────────
 const string Version = "0.1.0";
@@ -29,6 +30,7 @@
 
 // ── parse `check <path> [options]` ───────────────────────────────────────────
 var positionals = new List<string>();
+var ruleFiles = new List<string>();
 string language = "auto";
 bool json = false, noColor = false;
 double? maxScore = null;
@@ -42,6 +44,7 @@
         case "--lang": language = Next(); break;
         case "--json": json = true; break;
         case "--no-color": noColor = true; break;
+        case "--rules": ruleFiles.Add(Next()); break;
         case "--max-score": maxScore = double.Parse(Next(), System.Globalization.CultureInfo.InvariantCulture); break;
         case "--top": top = int.Parse(Next()); break;
         default:
@@ -78,7 +81,16 @@
     return 2;
 }
 
-var result = new AiWritingAnalyzer().Analyze(text, language);
+// Load any custom catalogs (--rules file.json, repeatable).
+var extraPacks = new List<RulePack>();
+foreach (var rf in ruleFiles)
+{
+    if (!File.Exists(rf)) { Console.Error.WriteLine($"Rule-pack not found: {rf}"); return 2; }
+    try { extraPacks.Add(RulePack.FromJson(await File.ReadAllTextAsync(rf))); }
+    catch (Exception ex) { Console.Error.WriteLine($"Invalid rule-pack '{rf}': {ex.Message}"); return 2; }
+}
+
+var result = new AiWritingAnalyzer().Analyze(text, language, extraPacks);
 
 if (json)
 {
@@ -157,6 +169,7 @@ signsofai check <path> [options]
 
         OPTIONS
           --lang <auto|en|es>   Language of the text (default: auto-detect)
+          --rules <file.json>   Add a custom catalog (rule-pack). Repeatable.
           --json                Emit a JSON report instead of the pretty report
           --max-score <N>       Exit with code 1 if the overall score exceeds N (for CI gating)
           --top <N>             Show at most N findings in the pretty report (default: 10)

src/SignsOfAI.Core/AiWritingAnalyzer.cs

@@ -28,7 +28,12 @@ public static IReadOnlyList<IAnalyzer> DefaultAnalyzers() =>
 
     /// <param name="text">The text to analyze.</param>
     /// <param name="language">"en", "es", or null/"auto" to detect.</param>
-    public AnalysisResult Analyze(string text, string? language = null)
+    /// <param name="extraPacks">
+    /// Optional custom catalogs, merged on top of the built-in pack for the detected language.
+    /// A pack applies when its <c>Language</c> matches (or is "*"/"all"/empty); rules override
+    /// built-ins by id.
+    /// </param>
+    public AnalysisResult Analyze(string text, string? language = null, IReadOnlyList<RulePack>? extraPacks = null)
     {
         text ??= string.Empty;
 
@@ -38,7 +43,12 @@ public AnalysisResult Analyze(string text, string? language = null)
 
         var document = new TextDocument(text);
         var statistics = StatisticsCalculator.Compute(document);
-        var rulePack = RulePackLoader.Load(lang);
+
+        var builtIn = RulePackLoader.Load(lang);
+        var applicable = extraPacks?.Where(p => p.AppliesTo(lang)).ToList();
+        var rulePack = applicable is { Count: > 0 }
+            ? RulePack.Merge(lang, [builtIn, .. applicable])
+            : builtIn;
 
         var context = new AnalysisContext
         {

src/SignsOfAI.Core/Rules/RulePack.cs

@@ -44,14 +44,49 @@ public sealed class PatternRule
     public string? Evidence { get; init; }
 }
 
-/// <summary>A full language rule-pack, deserialized from an embedded JSON resource.</summary>
+/// <summary>A full rule-pack (a "catalog") — built-in or supplied by the user.</summary>
 public sealed class RulePack
 {
+    /// <summary>"en", "es", or "*"/"all"/empty for a language-agnostic custom catalog.</summary>
     public required string Language { get; init; }
 
     public LexicalRule[] Lexical { get; init; } = [];
 
     public PatternRule[] Patterns { get; init; } = [];
+
+    /// <summary>Parse a rule-pack from JSON (the same schema as the built-in packs).</summary>
+    public static RulePack FromJson(string json) =>
+        JsonSerializer.Deserialize(json, RulePackJsonContext.Default.RulePack)
+        ?? throw new InvalidOperationException("Rule-pack JSON deserialized to null.");
+
+    public string ToJson() => JsonSerializer.Serialize(this, RulePackJsonContext.Default.RulePack);
+
+    /// <summary>
+    /// Combine several catalogs into one. Rules are keyed by <c>Id</c>, so a later pack overrides an
+    /// earlier one with the same id — this lets a custom catalog tweak or replace a built-in rule.
+    /// </summary>
+    public static RulePack Merge(string language, IEnumerable<RulePack> packs)
+    {
+        var lexical = new Dictionary<string, LexicalRule>(StringComparer.Ordinal);
+        var patterns = new Dictionary<string, PatternRule>(StringComparer.Ordinal);
+        foreach (var pack in packs)
+        {
+            // A custom pack parsed from JSON may omit a section, leaving the array null under source-gen.
+            foreach (var rule in pack.Lexical ?? []) lexical[rule.Id] = rule;
+            foreach (var rule in pack.Patterns ?? []) patterns[rule.Id] = rule;
+        }
+        return new RulePack
+        {
+            Language = language,
+            Lexical = [.. lexical.Values],
+            Patterns = [.. patterns.Values],
+        };
+    }
+
+    /// <summary>Whether this catalog applies to a given detected language.</summary>
+    public bool AppliesTo(string language) =>
+        string.IsNullOrWhiteSpace(Language) || Language is "*" or "all"
+        || Language.Equals(language, StringComparison.OrdinalIgnoreCase);
 }
 
 [JsonSourceGenerationOptions(