humanizer-rb 0.1.0

data/lib/humanizer/stats.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Humanizer
+  module Stats
+    Result = Struct.new(
+      :word_count, :unique_word_count, :sentence_count, :paragraph_count,
+      :avg_word_length, :avg_sentence_length, :sentence_length_std_dev,
+      :sentence_length_variation, :burstiness, :type_token_ratio,
+      :function_word_ratio, :trigram_repetition, :avg_paragraph_length,
+      :flesch_kincaid, :sentence_lengths,
+      keyword_init: true
+    )
+
+    EMPTY = Result.new(
+      word_count: 0, unique_word_count: 0, sentence_count: 0, paragraph_count: 0,
+      avg_word_length: 0, avg_sentence_length: 0, sentence_length_std_dev: 0,
+      sentence_length_variation: 0, burstiness: 0, type_token_ratio: 0,
+      function_word_ratio: 0, trigram_repetition: 0, avg_paragraph_length: 0,
+      flesch_kincaid: 0, sentence_lengths: []
+    ).freeze
+
+    module_function
+
+    def compute(text)
+      return EMPTY if text.nil? || !text.is_a?(String) || text.strip.empty?
+
+      words = TextUtils.tokenize(text)
+      return EMPTY if words.empty?
+
+      sentences = split_sentences(text)
+      paragraphs = text.split(/\n\s*\n/).select { |p| p.strip.length > 0 }
+
+      # Word-level stats
+      word_count = words.length
+      unique_words = words.uniq
+      type_token_ratio = unique_words.length.to_f / word_count
+      avg_word_length = words.sum { |w| w.length }.to_f / word_count
+
+      # Sentence-level stats
+      sentence_lengths = sentences.map { |s| TextUtils.tokenize(s).length }.select { |n| n > 0 }
+      sentence_count = sentence_lengths.length
+
+      avg_sentence_length = 0.0
+      sentence_length_std_dev = 0.0
+      sentence_length_variation = 0.0
+      burstiness = 0.0
+
+      if sentence_count > 1
+        avg_sentence_length = sentence_lengths.sum.to_f / sentence_count
+
+        variance = sentence_lengths.sum { |len| (len - avg_sentence_length) ** 2 }.to_f / sentence_count
+        sentence_length_std_dev = Math.sqrt(variance)
+
+        sentence_length_variation = avg_sentence_length > 0 ? sentence_length_std_dev / avg_sentence_length : 0.0
+
+        consecutive_diff_sum = (1...sentence_lengths.length).sum { |i|
+          (sentence_lengths[i] - sentence_lengths[i - 1]).abs
+        }
+        avg_consecutive_diff = consecutive_diff_sum.to_f / (sentence_lengths.length - 1)
+        burstiness = avg_sentence_length > 0 ? avg_consecutive_diff / avg_sentence_length : 0.0
+      elsif sentence_count == 1
+        avg_sentence_length = sentence_lengths[0].to_f
+      end
+
+      # Function word ratio
+      function_word_set = Vocabulary::FUNCTION_WORDS.map(&:downcase).to_set
+      function_word_count = words.count { |w| function_word_set.include?(w) }
+      function_word_ratio = function_word_count.to_f / word_count
+
+      # N-gram repetition
+      trigram_repetition = compute_ngram_repetition(words, 3)
+
+      # Paragraph stats
+      paragraph_count = paragraphs.length
+      avg_paragraph_length = paragraph_count > 0 ?
+        paragraphs.sum { |p| TextUtils.tokenize(p).length }.to_f / paragraph_count : 0.0
+
+      # Readability (Flesch-Kincaid Grade Level)
+      syllable_count = words.sum { |w| estimate_syllables(w) }
+      flesch_kincaid = sentence_count > 0 ?
+        0.39 * (word_count.to_f / sentence_count) + 11.8 * (syllable_count.to_f / word_count) - 15.59 : 0.0
+
+      Result.new(
+        word_count: word_count,
+        unique_word_count: unique_words.length,
+        sentence_count: sentence_count,
+        paragraph_count: paragraph_count,
+        avg_word_length: round3(avg_word_length),
+        avg_sentence_length: round3(avg_sentence_length),
+        sentence_length_std_dev: round3(sentence_length_std_dev),
+        sentence_length_variation: round3(sentence_length_variation),
+        burstiness: round3(burstiness),
+        type_token_ratio: round3(type_token_ratio),
+        function_word_ratio: round3(function_word_ratio),
+        trigram_repetition: round3(trigram_repetition),
+        avg_paragraph_length: round3(avg_paragraph_length),
+        flesch_kincaid: round3(flesch_kincaid),
+        sentence_lengths: sentence_lengths,
+      )
+    end
+
+    # Compute uniformity score (0-100). Higher = more uniform/AI-like.
+    def uniformity_score(stats)
+      return 0 if stats.word_count == 0
+
+      score = 0
+
+      # Low burstiness = more AI-like (max 25 points)
+      if stats.burstiness < 0.2 then score += 25
+      elsif stats.burstiness < 0.35 then score += 18
+      elsif stats.burstiness < 0.5 then score += 10
+      elsif stats.burstiness < 0.65 then score += 5
+      end
+
+      # Low sentence length variation = more AI-like (max 25 points)
+      if stats.sentence_length_variation < 0.2 then score += 25
+      elsif stats.sentence_length_variation < 0.35 then score += 18
+      elsif stats.sentence_length_variation < 0.5 then score += 10
+      elsif stats.sentence_length_variation < 0.65 then score += 5
+      end
+
+      # Low type-token ratio = more repetitive/AI-like (max 20 points)
+      if stats.word_count > 100
+        if stats.type_token_ratio < 0.35 then score += 20
+        elsif stats.type_token_ratio < 0.45 then score += 12
+        elsif stats.type_token_ratio < 0.55 then score += 5
+        end
+      end
+
+      # High trigram repetition = more AI-like (max 15 points)
+      if stats.trigram_repetition > 0.15 then score += 15
+      elsif stats.trigram_repetition > 0.1 then score += 10
+      elsif stats.trigram_repetition > 0.05 then score += 5
+      end
+
+      # Abnormally uniform paragraph lengths (max 15 points)
+      if stats.paragraph_count >= 3 && stats.sentence_count > 5
+        if stats.sentence_length_std_dev < 3 && stats.avg_sentence_length > 10
+          score += 15
+        end
+      end
+
+      [score, 100].min
+    end
+
+    # Split text into sentences, handling abbreviations
+    def split_sentences(text)
+      cleaned = text
+        .gsub(/\b(Mr|Mrs|Ms|Dr|Prof|Sr|Jr|etc|vs|approx|dept|est|vol)\./i, '\1' + "\u2024")
+        .gsub(/\b([A-Z])\./,  '\1' + "\u2024")
+        .gsub(/\b(\d+)\./,    '\1' + "\u2024")
+
+      sentences = cleaned
+        .split(/(?<=[.!?])\s+(?=[A-Z"'\u{201C}])|(?<=[.!?])$/)
+        .map { |s| s.gsub("\u2024", ".").strip }
+        .reject(&:empty?)
+
+      sentences
+    end
+
+    # Estimate syllable count for a word (English heuristic)
+    def estimate_syllables(word)
+      w = word.downcase.gsub(/[^a-z]/, "")
+      return 1 if w.length <= 3
+
+      vowel_groups = w.scan(/[aeiouy]+/)
+      count = vowel_groups.length > 0 ? vowel_groups.length : 1
+
+      # Subtract silent e
+      count -= 1 if w.end_with?("e") && !w.end_with?("le")
+      # Subtract for -ed that doesn't create syllable
+      count -= 1 if w.end_with?("ed") && w.length > 3 && w !~ /[aeiouy]ed$/
+
+      [count, 1].max
+    end
+
+    # Compute n-gram repetition rate
+    def compute_ngram_repetition(words, n)
+      return 0.0 if words.length < n
+
+      ngrams = Hash.new(0)
+      (0..words.length - n).each do |i|
+        gram = words[i, n].join(" ")
+        ngrams[gram] += 1
+      end
+
+      total = ngrams.length
+      return 0.0 if total == 0
+
+      repeated = ngrams.values.count { |c| c > 1 }
+      repeated.to_f / total
+    end
+
+    def round3(n)
+      (n * 1000).round / 1000.0
+    end
+  end
+end

data/lib/humanizer/text_utils.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Humanizer
+  module TextUtils
+    module_function
+
+    # Tokenize text into lowercase words
+    def tokenize(text)
+      text.downcase.gsub(/[^\w\s'-]/, " ").split(/\s+/).reject(&:empty?)
+    end
+
+    # Word count
+    def word_count(text)
+      text.strip.split(/\s+/).reject(&:empty?).length
+    end
+
+    # Find all regex matches with line/column info.
+    # Returns array of hashes with :match, :index, :line, :column, :suggestion, :confidence
+    def find_matches(text, regex, suggestion, confidence: "high")
+      results = []
+      lines = text.split("\n")
+      offset = 0
+
+      lines.each_with_index do |line, line_idx|
+        line.scan(regex) do
+          m = Regexp.last_match
+          results << {
+            match: m[0],
+            index: offset + m.begin(0),
+            line: line_idx + 1,
+            column: m.begin(0) + 1,
+            suggestion: suggestion.is_a?(Proc) ? suggestion.call(m[0]) : suggestion,
+            confidence: confidence,
+          }
+        end
+        offset += line.length + 1
+      end
+      results
+    end
+
+    # Count regex occurrences
+    def count_matches(text, regex)
+      m = text.scan(regex)
+      m.length
+    end
+
+    # Build a case-insensitive word-boundary regex for a word/phrase
+    def word_regex(word)
+      escaped = Regexp.escape(word)
+      /\b#{escaped}\b/i
+    end
+  end
+end

data/lib/humanizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Humanizer
+  VERSION = "0.1.0"
+end

data/lib/humanizer/vocabulary.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Humanizer
+  module Vocabulary
+    # ── Tier 1: Dead Giveaways ─────────────────────────────
+    # Words that appear 5-20x more often in AI text than human text.
+    TIER_1 = %w[
+      delve delving delved delves
+      tapestry vibrant crucial comprehensive
+      intricate intricacies pivotal testament
+      landscape bustling nestled realm
+      meticulous meticulously complexities
+      embark embarking embarked
+      robust
+      showcasing showcase showcased showcases
+      underscores underscoring underscored
+      fostering foster fostered fosters
+      seamless seamlessly groundbreaking renowned
+      synergy synergies
+      leverage leveraging leveraged
+      garner garnered garnering
+      interplay enduring
+      enhance enhanced enhancing enhancement
+      tapestry testament additionally daunting
+      ever-evolving
+      underscore
+      unpack unpacking unpacked
+      unraveling unravel
+      holistic holistically synergistic
+      actionable impactful learnings cadence bandwidth
+      net-net value-add
+    ].freeze
+
+    # Multi-word tier 1 entries (need separate handling)
+    TIER_1_PHRASES = [
+      "game changer", "game-changing", "game-changer",
+      "deep dive", "deep-dive", "at its core",
+      "best practices", "best-practices", "best practice",
+      "thought leader", "thought leadership",
+    ].freeze
+
+    # ── Tier 2: Suspicious in Density ──────────────────────
+    TIER_2 = %w[
+      furthermore moreover notably consequently subsequently
+      accordingly nonetheless henceforth indeed specifically
+      essentially ultimately arguably fundamentally inherently
+      profoundly
+      encompassing encompasses encompassed
+      endeavour endeavor endeavoring
+      elevate elevated elevating
+      alleviate alleviating
+      streamline streamlined streamlining
+      harness harnessing harnessed
+      unleash unleashing unleashed
+      revolutionize revolutionizing revolutionized
+      transformative transformation paramount multifaceted
+      spearhead spearheading spearheaded
+      bolster bolstering bolstered
+      catalyze catalyst catalyzed cornerstone
+      reimagine reimagining reimagined
+      empower empowering empowerment empowered
+      navigate navigating navigated
+      poised myriad nuanced nuance nuances
+      paradigm paradigms paradigm-shifting
+      holistic holistically
+      utilize utilizing utilization utilized
+      facilitate facilitated facilitating facilitation
+      elucidate elucidating
+      illuminate illuminating illuminated
+      invaluable cutting-edge innovative innovation
+      align aligns aligning alignment
+      dynamic dynamics impactful agile
+      scalable scalability proactive proactively synergistic
+      optimize optimizing optimization
+      resonate resonating resonated resonates
+      underscore underscored
+      cultivate cultivating cultivated
+      galvanize galvanizing
+      invigorate invigorating
+      juxtapose juxtaposing juxtaposition
+      underscore bolster
+      augment augmenting augmented
+      proliferate proliferating proliferation
+      burgeoning nascent ubiquitous plethora myriad
+      quintessential eclectic indelible
+      overarching underpinning underpinnings
+    ].freeze
+
+    # ── Tier 3: Context-Dependent ──────────────────────────
+    TIER_3 = %w[
+      significant significantly important importantly
+      effective effectively efficient efficiently
+      diverse diversity unique uniquely
+      key vital vitally critical critically
+      essential essentially valuable notable
+      remarkable remarkably substantial substantially
+      considerable considerably noteworthy
+      prominent prominently influential
+      thoughtful thoughtfully insightful insightfully
+      meaningful meaningfully purposeful purposefully
+      deliberate deliberately strategic strategically
+      integral indispensable instrumental imperative
+      exemplary commendable praiseworthy
+      sophisticated profound compelling captivating
+      exquisite impeccable formidable stellar
+      exceptional exceptionally extraordinary
+      unparalleled unprecedented monumental
+      groundbreaking trailblazing visionary
+      world-class state-of-the-art best-in-class
+    ].freeze
+
+    # ── AI Phrases ─────────────────────────────────────────
+    # Multi-word phrases that strongly signal AI authorship.
+    AI_PHRASES = [
+      # "In today's..." openers
+      { pattern: /\bin today'?s (digital age|fast-paced world|rapidly evolving|ever-changing|modern|interconnected)\b/i, tier: 1, fix: "(remove or be specific about what changed)" },
+      { pattern: /\bin today'?s world\b/i, tier: 2, fix: "(remove or be specific)" },
+
+      # "It is [worth/important] to note"
+      { pattern: /\bit is (worth|important to|essential to|crucial to) not(?:e|ing) that\b/i, tier: 1, fix: "(remove — just state the fact)" },
+      { pattern: /\bit should be noted that\b/i, tier: 1, fix: "(remove — just state the fact)" },
+      { pattern: /\bit bears mentioning that\b/i, tier: 1, fix: "(remove — just state the fact)" },
+
+      # Journey metaphors
+      { pattern: /\bpave the way (?:for|to)\b/i, tier: 1, fix: "enable / allow / lead to" },
+      { pattern: /\bat the forefront of\b/i, tier: 1, fix: "leading / first in" },
+      { pattern: /\bnavigate the (?:complexities|challenges|landscape)\b/i, tier: 1, fix: "handle / deal with / work through" },
+      { pattern: /\bharness the (?:power|potential|capabilities) of\b/i, tier: 1, fix: "use" },
+      { pattern: /\bembark on a journey\b/i, tier: 1, fix: "start / begin" },
+      { pattern: /\bpush the boundaries\b/i, tier: 1, fix: "(be specific about what changed)" },
+      { pattern: /\bfoster a (?:culture|environment|atmosphere|sense) of\b/i, tier: 1, fix: "build / create / encourage" },
+      { pattern: /\bunlock the (?:potential|power|full|true)\b/i, tier: 1, fix: "enable / use / improve" },
+      { pattern: /\bserves as a testament\b/i, tier: 1, fix: "shows / proves / demonstrates" },
+      { pattern: /\bplays a (?:crucial|pivotal|vital|key|significant|important|critical) role\b/i, tier: 1, fix: "matters for / helps / is important to" },
+      { pattern: /\bin the realm of\b/i, tier: 1, fix: "in" },
+      { pattern: /\bdelve into\b/i, tier: 1, fix: "explore / examine / look at" },
+      { pattern: /\bthe landscape of\b/i, tier: 1, fix: "(be specific — what part of the field?)" },
+      { pattern: /\bnestled (?:in|within|among)\b/i, tier: 1, fix: "located in / in / near" },
+
+      # Abstract verb phrases
+      { pattern: /\brise to the (?:occasion|challenge)\b/i, tier: 2, fix: "handle / face / tackle" },
+      { pattern: /\bstand at the (?:crossroads|intersection)\b/i, tier: 2, fix: "(be specific about the choice)" },
+      { pattern: /\bshape the (?:future|trajectory|direction)\b/i, tier: 2, fix: "(be specific about how)" },
+      { pattern: /\btip of the iceberg\b/i, tier: 2, fix: "one example / a small part" },
+      { pattern: /\bdouble-edged sword\b/i, tier: 2, fix: "has tradeoffs / cuts both ways" },
+      { pattern: /\ba testament to\b/i, tier: 1, fix: "shows / proves" },
+      { pattern: /\bthe dawn of\b/i, tier: 2, fix: "the start of / the beginning of" },
+      { pattern: /\bthe fabric of\b/i, tier: 1, fix: "(be concrete)" },
+      { pattern: /\bthe tapestry of\b/i, tier: 1, fix: "(be concrete)" },
+
+      # Hedging stacks
+      { pattern: /\bcould potentially\b/i, tier: 1, fix: "could / might" },
+      { pattern: /\bmight possibly\b/i, tier: 1, fix: "might" },
+      { pattern: /\bcould possibly\b/i, tier: 1, fix: "could" },
+      { pattern: /\bperhaps potentially\b/i, tier: 1, fix: "perhaps / maybe" },
+      { pattern: /\bmay potentially\b/i, tier: 1, fix: "may" },
+      { pattern: /\bcould conceivably\b/i, tier: 1, fix: "could" },
+
+      # Chatbot filler
+      { pattern: /\bI hope this helps\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\blet me know if (?:you|there)\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bwould you like me to\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bfeel free to\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bdon'?t hesitate to\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bhappy to help\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bhere is (?:a |an |the )?(?:comprehensive |brief |quick )?(?:overview|summary|breakdown|list|guide|explanation|look)\b/i, tier: 1, fix: "(remove — start with the content)" },
+      { pattern: /\bI'?d be happy to\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bis there anything else\b/i, tier: 1, fix: "(remove)" },
+
+      # Sycophantic
+      { pattern: /\bgreat question\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bexcellent (?:question|point|observation)\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bthat'?s a (?:great|excellent|wonderful|fantastic|good|insightful|thoughtful) (?:question|point|observation)\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\byou'?re absolutely right\b/i, tier: 1, fix: "(remove or address the substance)" },
+      { pattern: /\byou raise a (?:great|good|excellent|valid|important) point\b/i, tier: 1, fix: "(remove or address the substance)" },
+
+      # Cutoff disclaimers
+      { pattern: /\bas of (?:my|this) (?:last|latest|most recent) (?:training|update|knowledge)\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bwhile (?:specific )?details are (?:limited|scarce|not available)\b/i, tier: 1, fix: "(remove — research it or omit the claim)" },
+      { pattern: /\bbased on (?:available|my|current) (?:information|knowledge|understanding|data)\b/i, tier: 1, fix: "(remove)" },
+      { pattern: /\bup to my (?:last )?training\b/i, tier: 1, fix: "(remove)" },
+
+      # Generic conclusions
+      { pattern: /\bthe future (?:looks|is|remains) bright\b/i, tier: 1, fix: "(end with a specific fact or plan)" },
+      { pattern: /\bexciting times (?:lie|lay|are) ahead\b/i, tier: 1, fix: "(end with a specific fact or plan)" },
+      { pattern: /\bcontinue (?:this|their|our|the) journey\b/i, tier: 1, fix: "(be specific about what happens next)" },
+      { pattern: /\bjourney towards? (?:excellence|success|greatness)\b/i, tier: 1, fix: "(be specific)" },
+      { pattern: /\bstep in the right direction\b/i, tier: 1, fix: "(be specific about the outcome)" },
+      { pattern: /\bonly time will tell\b/i, tier: 1, fix: "(end with what you actually know)" },
+      { pattern: /\bthe possibilities are (?:endless|limitless|infinite)\b/i, tier: 1, fix: "(be specific about what's possible)" },
+      { pattern: /\bpoised for (?:growth|success|greatness|expansion)\b/i, tier: 1, fix: "(cite evidence or remove)" },
+      { pattern: /\bwatch this space\b/i, tier: 2, fix: "(end with something concrete)" },
+      { pattern: /\bstay tuned\b/i, tier: 2, fix: "(end with something concrete)" },
+      { pattern: /\bremains to be seen\b/i, tier: 2, fix: "(state what you do know)" },
+
+      # Formulaic filler
+      { pattern: /\bin order to\b/i, tier: 2, fix: "to" },
+      { pattern: /\bdue to the fact that\b/i, tier: 1, fix: "because" },
+      { pattern: /\bat this point in time\b/i, tier: 1, fix: "now" },
+      { pattern: /\bin the event that\b/i, tier: 1, fix: "if" },
+      { pattern: /\bhas the ability to\b/i, tier: 1, fix: "can" },
+      { pattern: /\bfor the purpose of\b/i, tier: 1, fix: "to / for" },
+      { pattern: /\bin light of the fact that\b/i, tier: 1, fix: "because / since" },
+      { pattern: /\bfirst and foremost\b/i, tier: 2, fix: "first" },
+      { pattern: /\blast but not least\b/i, tier: 2, fix: "finally" },
+      { pattern: /\bat the end of the day\b/i, tier: 2, fix: "(remove or be specific)" },
+      { pattern: /\bwhen it comes to\b/i, tier: 2, fix: "for / regarding" },
+      { pattern: /\bthe fact of the matter is\b/i, tier: 1, fix: "(remove — just state it)" },
+      { pattern: /\bin terms of\b/i, tier: 3, fix: "for / about / regarding" },
+      { pattern: /\bat its core\b/i, tier: 2, fix: "(remove or be specific)" },
+      { pattern: /\bit goes without saying\b/i, tier: 2, fix: "(if it goes without saying, don't say it)" },
+      { pattern: /\bneedless to say\b/i, tier: 2, fix: "(if needless to say, don't say it)" },
+
+      # v2.2 additions
+      { pattern: /\blet'?s dive in\b/i, tier: 1, fix: "(just start)" },
+      { pattern: /\blet'?s (?:break this|break it) down\b/i, tier: 1, fix: "(just explain)" },
+      { pattern: /\bhere'?s the thing\b/i, tier: 2, fix: "(just say it)" },
+      { pattern: /\bthe reality is\b/i, tier: 2, fix: "(state the fact)" },
+      { pattern: /\bmoving forward\b/i, tier: 2, fix: "next / from now on" },
+      { pattern: /\bcircle back\b/i, tier: 1, fix: "return to / revisit" },
+      { pattern: /\btouch base\b/i, tier: 1, fix: "talk / check in" },
+      { pattern: /\bgoing forward\b/i, tier: 2, fix: "from now on" },
+      { pattern: /\bkey takeaways?\b/i, tier: 1, fix: "main point(s)" },
+      { pattern: /\bvalue proposition\b/i, tier: 2, fix: "benefit / value" },
+      { pattern: /\bcore competenc(?:y|ies)\b/i, tier: 2, fix: "strength(s)" },
+      { pattern: /\bbest-in-class\b/i, tier: 1, fix: "excellent / (be specific)" },
+      { pattern: /\bworld-class\b/i, tier: 1, fix: "(be specific)" },
+      { pattern: /\bcutting-edge\b/i, tier: 1, fix: "(be specific)" },
+      { pattern: /\bstate-of-the-art\b/i, tier: 1, fix: "(be specific or cite)" },
+      { pattern: /\bgold standard\b/i, tier: 2, fix: "(cite the standard)" },
+      { pattern: /\blow-hanging fruit\b/i, tier: 1, fix: "easy wins / quick wins" },
+      { pattern: /\bpain points?\b/i, tier: 1, fix: "problem(s)" },
+      { pattern: /\bdeep dive\b/i, tier: 1, fix: "detailed look / analysis" },
+      { pattern: /\bparadigm shift\b/i, tier: 1, fix: "major change" },
+      { pattern: /\bdouble-click (?:on)?\b/i, tier: 1, fix: "examine / look closer at" },
+      { pattern: /\bloop (?:you |me |them )in\b/i, tier: 2, fix: "include / inform" },
+      { pattern: /\btable this\b/i, tier: 2, fix: "postpone / set aside" },
+      { pattern: /\bpivot to\b/i, tier: 2, fix: "switch to / change to" },
+      { pattern: /\bsynch? (?:up )?(?:on|about)\b/i, tier: 2, fix: "discuss / align on" },
+      { pattern: /\brun it up the flagpole\b/i, tier: 1, fix: "propose / suggest" },
+      { pattern: /\bboil the ocean\b/i, tier: 1, fix: "attempt too much" },
+      { pattern: /\bmove the needle\b/i, tier: 1, fix: "make progress / have impact" },
+      { pattern: /\bopen the kimono\b/i, tier: 1, fix: "share / be transparent" },
+      { pattern: /\bdrink the Kool-Aid\b/i, tier: 2, fix: "believe / accept" },
+    ].freeze
+
+    # ── Function Words ─────────────────────────────────────
+    FUNCTION_WORDS = %w[
+      the be to of and a in that have I it for not on with
+      he as you do at this but his by from they we say her
+      she or an will my one all would there their what so
+      up out if about who get which go me when make can like
+      time no just him know take people into year your good
+      some could them see other than then now look only come
+      its over think also back after use two how our work
+      first well way even new want because any these give
+      day most us
+    ].freeze
+  end
+end

data/lib/humanizer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "humanizer/version"
+require_relative "humanizer/text_utils"
+require_relative "humanizer/vocabulary"
+require_relative "humanizer/stats"
+require_relative "humanizer/patterns"
+require_relative "humanizer/analyzer"
+require_relative "humanizer/humanizer_engine"
+
+module Humanizer
+  # Quick score (0-100, higher = more AI-like)
+  def self.score(text)
+    Analyzer.score(text)
+  end
+
+  # Full analysis with details
+  def self.analyze(text, **opts)
+    Analyzer.analyze(text, **opts)
+  end
+
+  # Humanization suggestions
+  def self.humanize(text, **opts)
+    HumanizerEngine.humanize(text, **opts)
+  end
+
+  # Safe mechanical auto-fixes
+  def self.auto_fix(text)
+    HumanizerEngine.auto_fix(text)
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: humanizer-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christian Genco
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-16 00:00:00.000000000 Z
+dependencies: []
+description: Scores text 0-100 for AI writing patterns using 28 pattern detectors,
+  500+ vocabulary terms, and statistical text analysis. Ruby port of the humanizer
+  Node.js tool.
+email:
+- christian@gen.co
+executables:
+- humanizer
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/humanizer
+- lib/humanizer.rb
+- lib/humanizer/analyzer.rb
+- lib/humanizer/humanizer_engine.rb
+- lib/humanizer/patterns.rb
+- lib/humanizer/stats.rb
+- lib/humanizer/text_utils.rb
+- lib/humanizer/version.rb
+- lib/humanizer/vocabulary.rb
+homepage: https://github.com/christiangenco/humanizer-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/christiangenco/humanizer-rb
+  source_code_uri: https://github.com/christiangenco/humanizer-rb
+  changelog_uri: https://github.com/christiangenco/humanizer-rb/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Detect AI-generated writing patterns
+test_files: []