@mrclrchtr/supi-flow 0.6.1

package/skills/supi-flow-slop-detect/references/vocabulary.json

@@ -0,0 +1,161 @@
+{
+  "tier1": [
+    {
+      "term": "delve",
+      "score": 3,
+      "context": "\"delve into\"",
+      "replacement": "explore, examine, look at"
+    },
+    {
+      "term": "tapestry",
+      "score": 3,
+      "context": "\"rich tapestry\"",
+      "replacement": "mix, combination, variety"
+    },
+    {
+      "term": "realm",
+      "score": 3,
+      "context": "\"in the realm of\"",
+      "replacement": "in, within, regarding"
+    },
+    {
+      "term": "embark",
+      "score": 3,
+      "context": "\"embark on a journey\"",
+      "replacement": "start, begin"
+    },
+    { "term": "beacon", "score": 3, "context": "\"a beacon of\"", "replacement": "example, model" },
+    {
+      "term": "spearheaded",
+      "score": 3,
+      "context": "formal attribution",
+      "replacement": "led, started"
+    },
+    { "term": "leverage", "score": 3, "context": "business jargon", "replacement": "use, apply" },
+    {
+      "term": "robust",
+      "score": 3,
+      "context": "quality signal",
+      "replacement": "solid, strong, reliable"
+    },
+    {
+      "term": "seamless",
+      "score": 3,
+      "context": "integration claim",
+      "replacement": "smooth, easy, simple"
+    },
+    {
+      "term": "pivotal",
+      "score": 3,
+      "context": "importance marker",
+      "replacement": "key, important"
+    },
+    {
+      "term": "multifaceted",
+      "score": 3,
+      "context": "complexity signal",
+      "replacement": "complex, varied"
+    },
+    {
+      "term": "comprehensive",
+      "score": 3,
+      "context": "scope claim",
+      "replacement": "thorough, complete"
+    },
+    {
+      "term": "nuanced",
+      "score": 3,
+      "context": "sophistication signal",
+      "replacement": "subtle, detailed"
+    },
+    {
+      "term": "meticulous",
+      "score": 3,
+      "context": "care signal",
+      "replacement": "careful, detailed"
+    },
+    {
+      "term": "intricate",
+      "score": 3,
+      "context": "complexity marker",
+      "replacement": "detailed, complex"
+    },
+    {
+      "term": "showcasing",
+      "score": 3,
+      "context": "display verb",
+      "replacement": "showing, displaying"
+    },
+    {
+      "term": "streamline",
+      "score": 3,
+      "context": "optimization verb",
+      "replacement": "simplify, improve"
+    },
+    {
+      "term": "facilitate",
+      "score": 3,
+      "context": "enablement verb",
+      "replacement": "enable, help, allow"
+    },
+    { "term": "utilize", "score": 3, "context": "formal \"use\"", "replacement": "use" }
+  ],
+  "tier2": [
+    { "term": "moreover", "score": 2, "category": "Transition overuse" },
+    { "term": "furthermore", "score": 2, "category": "Transition overuse" },
+    { "term": "indeed", "score": 2, "category": "Transition overuse" },
+    { "term": "notably", "score": 2, "category": "Transition overuse" },
+    { "term": "subsequently", "score": 2, "category": "Transition overuse" },
+    { "term": "significantly", "score": 2, "category": "Intensity clustering" },
+    { "term": "substantially", "score": 2, "category": "Intensity clustering" },
+    { "term": "fundamentally", "score": 2, "category": "Intensity clustering" },
+    { "term": "profoundly", "score": 2, "category": "Intensity clustering" },
+    { "term": "potentially", "score": 2, "category": "Hedging stacks" },
+    { "term": "typically", "score": 2, "category": "Hedging stacks" },
+    { "term": "might", "score": 2, "category": "Hedging stacks" },
+    { "term": "perhaps", "score": 2, "category": "Hedging stacks" },
+    { "term": "revolutionize", "score": 2, "category": "Action inflation" },
+    { "term": "transform", "score": 2, "category": "Action inflation" },
+    { "term": "unlock", "score": 2, "category": "Action inflation" },
+    { "term": "unleash", "score": 2, "category": "Action inflation" },
+    { "term": "elevate", "score": 2, "category": "Action inflation" },
+    { "term": "crucial", "score": 2, "category": "Empty emphasis" },
+    { "term": "vital", "score": 2, "category": "Empty emphasis" },
+    { "term": "essential", "score": 2, "category": "Empty emphasis" },
+    { "term": "paramount", "score": 2, "category": "Empty emphasis" }
+  ],
+  "tier3": [
+    {
+      "term": "in today's fast-paced world",
+      "score": 4,
+      "replacement": "Delete — start with the point"
+    },
+    {
+      "term": "it's worth noting that",
+      "score": 3,
+      "replacement": "Delete — just state the thing"
+    },
+    { "term": "at its core", "score": 2, "replacement": "\"Fundamentally\" or delete" },
+    {
+      "term": "cannot be overstated",
+      "score": 3,
+      "replacement": "\"is important because [reason]\""
+    },
+    { "term": "navigate the complexities", "score": 4, "replacement": "handle, work through" },
+    { "term": "unlock the potential", "score": 4, "replacement": "enable, make possible" },
+    { "term": "a testament to", "score": 3, "replacement": "shows, demonstrates" },
+    { "term": "treasure trove of", "score": 3, "replacement": "collection, set" },
+    { "term": "game changer", "score": 3, "replacement": "Delete — be specific" },
+    { "term": "ever-evolving landscape", "score": 4, "replacement": "Delete — be specific" },
+    { "term": "look no further", "score": 4, "replacement": "Delete — state the answer" },
+    { "term": "hustle and bustle", "score": 3, "replacement": "Delete — filler" }
+  ],
+  "tier4": [
+    { "term": "I'd be happy to", "score": 2, "issue": "Servile opener" },
+    { "term": "Great question!", "score": 2, "issue": "Empty validation" },
+    { "term": "Absolutely!", "score": 2, "issue": "Over-agreement" },
+    { "term": "That's a wonderful point", "score": 2, "issue": "Flattery" },
+    { "term": "I'm glad you asked", "score": 2, "issue": "Filler" },
+    { "term": "You're absolutely right", "score": 2, "issue": "Sycophancy" }
+  ]
+}

package/skills/supi-flow-slop-detect/scripts/slop-helpers.ts

@@ -0,0 +1,301 @@
+/**
+ * Shared utilities for slop detection scripts.
+ *
+ * Cross-platform Node.js/TypeScript — runs wherever pi runs.
+ * Use via: pnpm exec jiti <script>.ts <file>
+ */
+
+import { readFileSync } from "node:fs";
+
+export type DocProfile = "skill" | "technical" | "prose";
+
+interface ArrowConnectorStats {
+  total: number;
+  technical: number;
+  prose: number;
+}
+
+const ARROW_CONNECTOR_PATTERN = /->|→/g;
+const TECHNICAL_TOKEN_PATTERN = /[A-Za-z0-9_./-]+/g;
+const ARROW_PROSE_START_WORDS = new Set([
+  "a",
+  "an",
+  "are",
+  "can",
+  "does",
+  "helps",
+  "improves",
+  "is",
+  "it",
+  "lets",
+  "makes",
+  "means",
+  "shows",
+  "that",
+  "the",
+  "their",
+  "there",
+  "these",
+  "this",
+  "those",
+  "we",
+  "you",
+]);
+
+/** Read a file as UTF-8 string. */
+export function readFile(path: string): string {
+  return readFileSync(path, "utf-8");
+}
+
+/** Strip fenced code blocks from markdown content. */
+export function stripCodeBlocks(content: string): string {
+  return content.replace(/```[\s\S]*?```/g, "");
+}
+
+/** Strip inline code spans from markdown content. */
+export function stripInlineCode(content: string): string {
+  return content.replace(/`[^`]+`/g, "");
+}
+
+/** Detect the document profile used for structural scoring. */
+export function detectDocProfile(filePath: string): DocProfile {
+  if (/[\\/]skills[\\/].*[\\/]SKILL\.md$/i.test(filePath)) return "skill";
+  if (/(?:^|[\\/])README\.md$/i.test(filePath) || /[\\/]docs[\\/].*\.md$/i.test(filePath)) {
+    return "technical";
+  }
+  return "prose";
+}
+
+/** Count non-empty lines. */
+export function countNonEmpty(content: string): number {
+  return content.split("\n").filter((l) => l.trim().length > 0).length;
+}
+
+/** Count words in text. */
+export function countWords(text: string): number {
+  return text.split(/[\s\n]+/).filter((w) => w.length > 0).length;
+}
+
+/** Count sentences in text (naive: split on sentence-ending punctuation). */
+export function countSentences(text: string): number {
+  return text.split(/[.!?]+/).filter((s) => s.trim().length > 0).length || 1;
+}
+
+/** Count paragraphs (blocks separated by blank lines). */
+export function countParagraphs(text: string): number {
+  return text.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length || 1;
+}
+
+/** Count em dashes in text. */
+export function countEmDashes(text: string): number {
+  return (text.match(/—/g) || []).length;
+}
+
+/** Count semicolons in text. */
+export function countSemicolons(text: string): number {
+  return (text.match(/;/g) || []).length;
+}
+
+/** Count colons in text. */
+export function countColons(text: string): number {
+  return (text.match(/:/g) || []).length;
+}
+
+function isTechnicalArrowContext(leftTokens: string[], rightTokens: string[]): boolean {
+  if (leftTokens.length === 0 || rightTokens.length === 0) return false;
+
+  const leftFirst = leftTokens[0]?.toLowerCase() ?? "";
+  const rightFirst = rightTokens[0]?.toLowerCase() ?? "";
+
+  if (ARROW_PROSE_START_WORDS.has(leftFirst) || ARROW_PROSE_START_WORDS.has(rightFirst)) {
+    return false;
+  }
+
+  return leftTokens.length <= 3 && rightTokens.length <= 3;
+}
+
+/** Analyze arrow connectors in prose and split technical notation from prose shorthand. */
+export function analyzeArrowConnectors(content: string): ArrowConnectorStats {
+  const prose = stripInlineCode(stripCodeBlocks(content));
+  const lines = prose.split("\n");
+
+  let total = 0;
+  let technical = 0;
+
+  for (const line of lines) {
+    const matches = [...line.matchAll(ARROW_CONNECTOR_PATTERN)];
+    total += matches.length;
+
+    for (const match of matches) {
+      const index = match.index ?? -1;
+      if (index < 0) continue;
+
+      const leftTokens = [...line.slice(0, index).matchAll(TECHNICAL_TOKEN_PATTERN)]
+        .map((token) => token[0])
+        .slice(-3);
+      const rightTokens = [...line.slice(index + match[0].length).matchAll(TECHNICAL_TOKEN_PATTERN)]
+        .map((token) => token[0])
+        .slice(0, 3);
+
+      if (isTechnicalArrowContext(leftTokens, rightTokens)) {
+        technical++;
+      }
+    }
+  }
+
+  return {
+    total,
+    technical,
+    prose: Math.max(0, total - technical),
+  };
+}
+
+/** Count plus-sign conjunctions in prose (excluding code blocks). */
+export function countPlusSigns(content: string): number {
+  const prose = stripInlineCode(stripCodeBlocks(content));
+  return (prose.match(/\s\+\s/g) || []).length;
+}
+
+/** Count bullet list items (lines starting with -, *, +). */
+export function countBulletLines(content: string): number {
+  return (content.match(/^[ \t]*[-*+]\s/gm) || []).length;
+}
+
+/** Count participial phrase tail-loading patterns. */
+export function countParticipialTails(text: string): number {
+  // Pattern: [main clause], [present participle] [detail].
+  const pattern =
+    /,\s*(enabling|making|creating|providing|leading|marking|contributing|resulting|allowing|using|bringing|taking|giving|setting)\s+\w+/gi;
+  return (text.match(pattern) || []).length;
+}
+
+/** Count correlative conjunction pairs in proximity. */
+export function countCorrelativePairs(text: string): number {
+  const patterns = [
+    /not\s+only\s+\w+\s+but\s+also/gi,
+    /whether\s+\w+\s+or\s+\w+/gi,
+    /not\s+just\s+\w+\s+but/gi,
+    /both\s+\w+\s+and\s+\w+/gi,
+    /either\s+\w+\s+or\s+\w+/gi,
+    /neither\s+\w+\s+nor\s+\w+/gi,
+  ];
+  return patterns.reduce((sum, re) => sum + (text.match(re) || []).length, 0);
+}
+
+/** Count "From X to Y" range constructions. */
+export function countFromToRanges(text: string): number {
+  return (text.match(/\bfrom\s+\w+.*?\bto\s+\w+/gi) || []).length;
+}
+
+/** Get first and last paragraph from markdown (for conclusion mirroring check). */
+export function getFirstAndLastParagraph(content: string): [string, string] {
+  const paragraphs = content
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0 && !p.startsWith("---") && !p.startsWith("```"));
+
+  if (paragraphs.length < 2) {
+    return [paragraphs[0] || "", ""];
+  }
+
+  return [paragraphs[0] || "", paragraphs[paragraphs.length - 1] || ""];
+}
+
+/** Check if two paragraphs are near-paraphrases (simple word-overlap heuristic). */
+export function isNearParaphrase(a: string, b: string, threshold = 0.6): boolean {
+  const wordsA = new Set(
+    a
+      .toLowerCase()
+      .split(/[\s,.;:!?()]+/)
+      .filter((w) => w.length > 3),
+  );
+  const wordsB = new Set(
+    b
+      .toLowerCase()
+      .split(/[\s,.;:!?()]+/)
+      .filter((w) => w.length > 3),
+  );
+  if (wordsA.size === 0 || wordsB.size === 0) return false;
+
+  let overlap = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) overlap++;
+  }
+
+  const scoreA = overlap / wordsA.size;
+  const scoreB = overlap / wordsB.size;
+  return Math.max(scoreA, scoreB) > threshold;
+}
+
+/** Compute bullet-to-prose ratio (as fraction 0-1). */
+export function computeBulletRatio(content: string): number {
+  const totalLines = countNonEmpty(content);
+  if (totalLines === 0) return 0;
+  const bulletLines = countBulletLines(content);
+  return bulletLines / totalLines;
+}
+
+/** Detect intro-body-conclusion structure where the closing paragraph mirrors
+ *  the opening (the "five-paragraph essay" pattern common in AI-generated prose). */
+export function detectIntroBodyConclusion(content: string): boolean {
+  const paragraphs = content
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0 && !p.startsWith("```"));
+
+  if (paragraphs.length < 5) return false;
+
+  const firstLen = countWords(paragraphs[0]);
+  const lastLen = countWords(paragraphs[paragraphs.length - 1]);
+  const bodyLens = paragraphs.slice(1, -1).map(countWords);
+
+  // Heuristic: intro + 3+ body sections + short conclusion
+  const hasThreeMiddleSections = bodyLens.length >= 3;
+  const conclusionShorter = lastLen < firstLen * 0.8;
+  const startsWithIntro = firstLen > 20;
+
+  return hasThreeMiddleSections && conclusionShorter && startsWithIntro;
+}
+
+/** Compute paragraph word-count uniformity score (0-1).
+ *  Higher = more uniform paragraph lengths (strong AI signal).
+ *  Uses inverted coefficient of variation: 1 - min(1, stddev/mean).
+ *  Score > 0.7 means paragraphs are suspiciously uniform. */
+export function paragraphUniformity(content: string): number {
+  const paragraphs = content
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0 && !p.startsWith("```"))
+    .map(countWords);
+
+  if (paragraphs.length < 3) return 0;
+
+  const mean = paragraphs.reduce((s, w) => s + w, 0) / paragraphs.length;
+  if (mean === 0) return 0;
+  const variance = paragraphs.reduce((s, w) => s + (w - mean) ** 2, 0) / paragraphs.length;
+  const cv = Math.sqrt(variance) / mean;
+  return Math.round((1 - Math.min(1, cv)) * 100) / 100;
+}
+
+/** Compute sentence length clustering score (0-1). Ratio of sentences in 15-25 word range. */
+export function sentenceLengthClustering(text: string): number {
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  if (sentences.length < 3) return 0;
+
+  const wordCounts = sentences.map((s) => countWords(s));
+  const clustered = wordCounts.filter((w) => w >= 15 && w <= 25).length;
+  return clustered / sentences.length;
+}
+
+/** Count emoji-led bullet lines. */
+export function countEmojiBullets(content: string): number {
+  // Use alternation instead of a character class to avoid
+  // biome lint error about character + combining character in same class.
+  const emojiPattern = /^[ \t]*(?:✅|❌|🔴|🟢|🟡|⭐|🎯|💡|📌|🔹|🔸|✔️|✏️|📝|🚀|💪|🔧|⚡|🔥|💎)/gm;
+  return (content.match(emojiPattern) || []).length;
+}
+
+/** Output structured result as JSON. */
+export function outputJSON(data: unknown): void {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}