@stupify/cli 0.0.2 → 0.0.4

package/src/checks.ts

@@ -0,0 +1,221 @@
+import { checkId, type StupifyCheck } from "./types.ts";
+
+export const defaultChecks: readonly StupifyCheck[] = [
+  {
+    id: checkId("duplicated_schema"),
+    name: "Duplicated schema",
+    question: "Did the change duplicate an existing type, schema, payload, or DTO shape?",
+    lookFor: [
+      "local shape mirrors existing fields and maps them one-for-one",
+      "new response, payload, schema, or DTO adds no filtering, renaming, validation, or versioning",
+    ],
+    ignoreWhen: [
+      "test fixture, mock, or intentional external contract",
+      "public API DTO filters, omits, protects, renames, or versions fields",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find only local/private payload or schema shapes that clearly copy another local shape one-for-one without creating a boundary. Do not match ordinary Input/Output/Request/Response types by name alone, public DTOs, external contracts, client types, or types that omit/protect private fields.",
+    searchExamples: {
+      match: [
+        "LocalUserPayload repeats User fields and maps id/email/displayName one-for-one.",
+      ],
+      nonMatch: [
+        "PublicWebhookDto omits privateNotes from InternalJob.",
+        "A client type describes an external dependency boundary.",
+      ],
+    },
+  },
+  {
+    id: checkId("unnecessary_complexity"),
+    name: "Unnecessary complexity",
+    question: "Did the change add structure without buying clarity?",
+    lookFor: [
+      "helper, wrapper, service, layer, or extra file around simple logic without reuse",
+    ],
+    ignoreWhen: [
+      "isolates dependency, removes duplication, or improves testability",
+    ],
+    hookMode: "warn",
+    searchPrompt: `Find staged changes where a locally simple decision is made harder to understand by new indirection.
+Only match when the staged diff clearly shows:
+- a new named helper, wrapper, service, adapter, boundary, or abstraction
+- and the surrounding change still appears locally simple
+- and the new structure makes the decision harder to see
+Do not match:
+- plain conditionals, guard clauses, skip paths, or error handling
+- normal feature structure
+- exported utilities that are part of a real feature
+- command plumbing
+- prompt/instruction files
+- domain configuration
+- refactors that make ownership clearer
+- changes where the payoff is unclear from the diff
+Prefer no match over a weak match.`,
+    searchExamples: {
+      match: [
+        "A small inline operation becomes a helper/service/wrapper with one obvious caller.",
+        "A straightforward flow is split across files in a way that hides the decision.",
+        "A new abstraction appears before there is evidence it buys clarity, correctness, reuse, or isolation.",
+      ],
+      nonMatch: [
+        "A real external dependency boundary is isolated.",
+        "A security/auth boundary becomes clearer.",
+        "A refactor removes larger complexity elsewhere.",
+        "Framework-required structure is added.",
+      ],
+    },
+  },
+  {
+    id: checkId("fake_precision_windowing"),
+    name: "Fake precision windowing",
+    question: "Did the change add fake precision around model context?",
+    lookFor: [
+      "precise-looking counts, budgets, ratios, reports, or batching fields without useful behavior",
+    ],
+    ignoreWhen: [
+      "simple fixed cap or chunking",
+      "external API requirement",
+    ],
+  },
+  {
+    id: checkId("coauthored_slop"),
+    name: "Coauthored slop",
+    question: "Does author metadata contain co-author text?",
+    lookFor: [
+      "author signal contains coauhtoried, coauthored, or co-authored text",
+    ],
+    ignoreWhen: [
+      "normal Co-authored-by trailer in the commit body",
+    ],
+  },
+  {
+    id: checkId("mega_file"),
+    name: "Mega file",
+    question: "Is a touched non-config file over 1000 LOC?",
+    lookFor: [
+      "touched non-config source file over 1000 LOC",
+    ],
+    ignoreWhen: [
+      "config, lock, generated, fixture, or vendored file",
+    ],
+  },
+  {
+    id: checkId("over_commenting"),
+    name: "Over commenting",
+    question: "Did the change add noisy comments?",
+    lookFor: [
+      "comments restate obvious code or narrate simple logic",
+    ],
+    ignoreWhen: [
+      "comment explains intent, constraint, workaround, or public API behavior",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find staged changes where comments appear to substitute for judgment rather than clarify it.",
+    searchExamples: {
+      match: [
+        "New comments narrate obvious code instead of explaining tradeoffs.",
+        "A simple change gains multiple generic comments that restate control flow.",
+        "Comments make the code look more deliberate without adding useful reasoning.",
+      ],
+      nonMatch: [
+        "Comments explain a real domain constraint.",
+        "Comments document an external API quirk.",
+        "Comments clarify a surprising edge case.",
+        "Comments are sparse and specific.",
+        "Comments explain provider, finance, reconciliation, timezone, or ledger behavior.",
+      ],
+    },
+  },
+  {
+    id: checkId("lint_bypass"),
+    name: "Lint bypass",
+    question: "Did the change bypass lint or type rules?",
+    lookFor: [
+      "adds suppressions, any, broad casts, or weakens lint/typecheck config",
+    ],
+    ignoreWhen: [
+      "narrow suppression with a reason",
+      "type-level test",
+      "generated file convention",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find only broad lint/type bypasses that hide useful feedback. Match bare @ts-ignore, bare @ts-expect-error, broad casts, any, or eslint/biome suppressions without a concrete inline reason. Do not match targeted suppressions that include a reason for a known framework, test, mock, or external-library limitation.",
+    searchExamples: {
+      match: [
+        "A bare // @ts-ignore hides property access on unknown input.",
+      ],
+      nonMatch: [
+        "// @ts-expect-error explains a known external library typing gap.",
+      ],
+    },
+  },
+  {
+    id: checkId("inconsistent_patterns"),
+    name: "Inconsistent patterns",
+    question: "Does the change clash with nearby patterns?",
+    lookFor: [
+      "same job uses different naming, errors, state, imports, or layout than nearby files",
+    ],
+    ignoreWhen: [
+      "external API requires it",
+      "change follows a newer local convention",
+    ],
+  },
+  {
+    id: checkId("reinvented_utils"),
+    name: "Reinvented utils",
+    question: "Did the change recreate an existing utility?",
+    lookFor: [
+      "new helper duplicates local utility or standard library behavior",
+    ],
+    ignoreWhen: [
+      "existing utility has wrong contract",
+      "new helper is clearer as a tiny private expression",
+      "helper is domain-specific or used by multiple local call sites",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, group, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
+    searchExamples: {
+      match: [
+        "clampValue returns min, max, or value.",
+      ],
+      nonMatch: [
+        "formatCurrencyHelper is used by invoice and refund labels.",
+        "Subscription tier constants encode domain configuration.",
+      ],
+    },
+  },
+  {
+    id: checkId("operator_style_mismatch"),
+    name: "Operator style mismatch",
+    question: "Does the change read unlike the surrounding code?",
+    lookFor: [
+      "generic or template-like names, abstractions, comments, or control flow clash with local style",
+    ],
+    ignoreWhen: [
+      "generated, vendored, framework-required, or newer established local style",
+    ],
+    enabledByDefault: false,
+  },
+] as const;
+
+export function enabledChecks(checkIds: readonly string[] | null): readonly StupifyCheck[] {
+  if (!checkIds) return defaultChecks.filter((check) => check.enabledByDefault !== false);
+
+  return checksById(checkIds);
+}
+
+export function searchChecks(checkIds: readonly string[] | null): readonly StupifyCheck[] {
+  if (!checkIds) return defaultChecks.filter((check) => check.hookMode === "warn");
+
+  return checksById(checkIds);
+}
+
+function checksById(checkIds: readonly string[]): readonly StupifyCheck[] {
+  const checksById = new Map<string, StupifyCheck>(defaultChecks.map((check) => [check.id, check]));
+  return checkIds.map((id) => {
+    const check = checksById.get(id);
+    if (!check) throw new Error(`Unknown check: ${id}`);
+    return check;
+  });
+}

package/src/command.ts

@@ -0,0 +1,173 @@
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
+import type { Command, HookAction, ModelId, SearchSource } from "./types.ts";
+
+const DEFAULT_SINCE = "2 weeks ago";
+const DEFAULT_MAX_CANDIDATES = 10;
+const DEFAULT_MAX_SEARCH_INPUT_TOKENS = 12_000;
+
+type InputMode =
+  | Readonly<{ kind: "since"; since: string; source: "since" }>
+  | Readonly<{ kind: "stdin"; source: "stdin" }>
+  | Readonly<{ kind: "commit"; commit: string; source: "commit" }>
+  | Readonly<{ kind: "commits"; count: number; source: "commits" }>
+  | Readonly<{ kind: "staged"; source: "staged" }>;
+
+export function parseCommand(argv: readonly string[]): Command {
+  if (argv.length === 1 && isHelp(argv[0])) return { kind: "help" };
+  if (argv[0] === "bench") {
+    if (argv[1] !== "search" || !argv[2] || argv.length > 3) {
+      throw new Error("Usage: stupify bench search <config.json>");
+    }
+    return { kind: "bench-search", configPath: argv[2] };
+  }
+  if (argv[0] === "hook") {
+    const action = argv[1];
+    if (!action || !isHookAction(action) || argv.length > 2) {
+      throw new Error("Usage: stupify hook install|uninstall|status");
+    }
+    return { kind: "hook", action };
+  }
+  if (argv[0] === "doctor") {
+    if (argv.length > 1) throw new Error("Usage: stupify doctor");
+    return { kind: "doctor" };
+  }
+
+  type ParseState = Readonly<{
+    inputMode: InputMode;
+    explicitInputMode: boolean;
+    checkIds: readonly string[] | null;
+    json: boolean;
+    model: ModelId;
+    debugSem: boolean;
+    maxCandidates: number;
+    maxSearchInputTokens: number;
+    searchProfilePath: string | null;
+    includeCounterReasonInPrompt: boolean;
+  }>;
+
+  const initialState: ParseState = {
+    inputMode: { kind: "since", since: DEFAULT_SINCE, source: "since" },
+    explicitInputMode: false,
+    checkIds: null,
+    json: false,
+    model: DEFAULT_MODEL_ID,
+    debugSem: false,
+    maxCandidates: DEFAULT_MAX_CANDIDATES,
+    maxSearchInputTokens: DEFAULT_MAX_SEARCH_INPUT_TOKENS,
+    searchProfilePath: null,
+    includeCounterReasonInPrompt: false,
+  };
+
+  const finalState = parseFrom(0, initialState);
+  return {
+    ...finalState.inputMode,
+    mode: "search",
+    checkIds: finalState.checkIds,
+    json: finalState.json,
+    model: finalState.model,
+    debugSem: finalState.debugSem,
+    maxCandidates: finalState.maxCandidates,
+    maxSearchInputTokens: finalState.maxSearchInputTokens,
+    searchProfilePath: finalState.searchProfilePath,
+    includeCounterReasonInPrompt: finalState.includeCounterReasonInPrompt,
+  };
+
+  function parseFrom(index: number, state: ParseState): ParseState {
+    if (index >= argv.length) return state;
+
+    const arg = argv[index];
+
+    if (arg === "--mode") {
+      const value = argv[index + 1];
+      if (value !== "search") throw new Error("--mode only supports search.");
+      return parseFrom(index + 2, state);
+    }
+    if (arg === "--staged") return parseFrom(index + 1, setInputMode(state, { kind: "staged", source: "staged" }));
+    if (arg === "--stdin") return parseFrom(index + 1, setInputMode(state, { kind: "stdin", source: "stdin" }));
+    if (arg === "--json") return parseFrom(index + 1, { ...state, json: true });
+    if (arg === "--debug-sem") return parseFrom(index + 1, { ...state, debugSem: true });
+    if (arg === "--include-counter-reason-in-prompt") {
+      return parseFrom(index + 1, { ...state, includeCounterReasonInPrompt: true });
+    }
+
+    if (arg === "--search-profile") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) throw new Error("--search-profile requires a JSON profile path.");
+      return parseFrom(index + 2, { ...state, searchProfilePath: value });
+    }
+
+    if (arg === "--since") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) throw new Error("--since requires a git date, such as \"2 weeks ago\".");
+      return parseFrom(index + 2, setInputMode(state, { kind: "since", since: value, source: "since" }));
+    }
+
+    if (arg === "--commit") {
+      const value = argv[index + 1];
+      if (!value || !isSafeCommitArg(value)) throw new Error("Invalid commit.");
+      return parseFrom(index + 2, setInputMode(state, { kind: "commit", commit: value, source: "commit" }));
+    }
+
+    if (arg === "--commits") {
+      const value = argv[index + 1];
+      const count = Number(value);
+      if (!Number.isInteger(count) || count < 1) throw new Error("--commits requires a positive integer.");
+      return parseFrom(index + 2, setInputMode(state, { kind: "commits", count, source: "commits" }));
+    }
+
+    if (arg === "--checks") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) throw new Error("--checks requires a comma-separated list.");
+      const checkIds = value.split(",").map((id) => id.trim()).filter(Boolean);
+      if (checkIds.length === 0) throw new Error("--checks requires at least one check id.");
+      return parseFrom(index + 2, { ...state, checkIds });
+    }
+
+    if (arg === "--model") {
+      const value = argv[index + 1];
+      if (!value || !isModelId(value)) throw new Error(`--model must be one of: ${Object.keys(MODEL_REGISTRY).join(", ")}`);
+      return parseFrom(index + 2, { ...state, model: value });
+    }
+
+    if (arg === "--max-candidates") {
+      const value = argv[index + 1];
+      const maxCandidates = Number(value);
+      if (!Number.isInteger(maxCandidates) || maxCandidates < 1) {
+        throw new Error("--max-candidates requires a positive integer.");
+      }
+      return parseFrom(index + 2, { ...state, maxCandidates });
+    }
+
+    if (arg === "--max-search-input-tokens") {
+      const value = argv[index + 1];
+      const maxSearchInputTokens = Number(value);
+      if (!Number.isInteger(maxSearchInputTokens) || maxSearchInputTokens < 1) {
+        throw new Error("--max-search-input-tokens requires a positive integer.");
+      }
+      return parseFrom(index + 2, { ...state, maxSearchInputTokens });
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  function setInputMode(state: ParseState, next: InputMode): ParseState {
+    if (state.explicitInputMode) throw new Error("Choose only one input mode: --since, --stdin, --commit, --commits, or --staged.");
+    return { ...state, inputMode: next, explicitInputMode: true };
+  }
+}
+
+function isSafeCommitArg(value: string): boolean {
+  return value.length > 0 && !value.startsWith("-") && /^[A-Za-z0-9._/@~^:+-]+$/.test(value);
+}
+
+function isHelp(value: string): boolean {
+  return value === "--help" || value === "-h";
+}
+
+function isModelId(value: string): value is ModelId {
+  return value in MODEL_REGISTRY;
+}
+
+function isHookAction(value: string): value is HookAction {
+  return value === "install" || value === "uninstall" || value === "status";
+}

package/src/constants.ts

@@ -0,0 +1,56 @@
+export const VERSION = "0.0.4";
+import type { ModelConfig, ModelId } from "./types.ts";
+
+export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";
+
+export const MODEL_REGISTRY: Record<ModelId, ModelConfig> = {
+  "gemma-4-e2b": {
+    id: "gemma-4-e2b",
+    name: "Gemma 4 E2B Instruct Q4_K_M",
+    size: "about 3.1 GB",
+    file: "gemma-4-e2b-it-q4_k_m.gguf",
+    url: "https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF/resolve/main/gemma-4-E2B-it-Q4_K_M.gguf?download=true",
+  },
+  "gemma-4-e4b": {
+    id: "gemma-4-e4b",
+    name: "Gemma 4 E4B Instruct Q4_K_M",
+    size: "about 5.0 GB",
+    file: "gemma-4-e4b-it-q4_k_m.gguf",
+    url: "https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-Q4_K_M.gguf?download=true",
+  },
+  "gemma-4-26b-a4b": {
+    id: "gemma-4-26b-a4b",
+    name: "Gemma 4 26B A4B Instruct UD-IQ2_XXS",
+    size: "about 9.9 GB",
+    file: "gemma-4-26b-a4b-it-ud-iq2_xxs.gguf",
+    url: "https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF/resolve/main/gemma-4-26B-A4B-it-UD-IQ2_XXS.gguf?download=true",
+  },
+  "qwen3-4b-magicquant": {
+    id: "qwen3-4b-magicquant",
+    name: "Qwen3-4B-Instruct-2507 MagicQuant Q4_K_M",
+    size: "about 2.4 GB",
+    file: "qwen3-4b-instruct-2507-magicquant-q4_k_m.gguf",
+    url: "https://huggingface.co/magiccodingman/Qwen3-4B-Instruct-2507-Unsloth-MagicQuant-v2-GGUF/resolve/main/Model-MQ-Q4_K_M_1.gguf?download=true",
+  },
+  "qwen2.5-coder-1.5b": {
+    id: "qwen2.5-coder-1.5b",
+    name: "Qwen2.5-Coder-1.5B-Instruct Q4_K_M",
+    size: "about 1.1 GB",
+    file: "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf",
+    url: "https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf?download=true",
+  },
+  "qwen2.5-coder-7b": {
+    id: "qwen2.5-coder-7b",
+    name: "Qwen2.5-Coder-7B-Instruct Q4_K_M",
+    size: "about 4.7 GB",
+    file: "qwen2.5-coder-7b-instruct-q4_k_m.gguf",
+    url: "https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct-GGUF/resolve/main/qwen2.5-coder-7b-instruct-q4_k_m.gguf?download=true",
+  },
+  "qwen2.5-coder-32b": {
+    id: "qwen2.5-coder-32b",
+    name: "Qwen2.5-Coder-32B-Instruct Q4_K_M",
+    size: "about 19 GB",
+    file: "qwen2.5-coder-32b-instruct-q4_k_m.gguf",
+    url: "https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct-GGUF/resolve/main/qwen2.5-coder-32b-instruct-q4_k_m.gguf?download=true",
+  },
+};

package/src/counter-scout.ts

@@ -0,0 +1,175 @@
+import type { CheckId, SemCandidate, SemChange, SemChangeSet, StupifyCheck } from "./types.ts";
+
+type Signal = Readonly<{
+  checkId: CheckId;
+  entityId: string;
+  reasonCode: string;
+}>;
+
+type SignalBucket = Readonly<{
+  checkId: CheckId;
+  total: number;
+  examples: readonly Signal[];
+}>;
+
+const MAX_COUNTER_EXAMPLES_PER_CHECK = 4;
+
+export function counterScoutTargets(
+  changeSet: SemChangeSet,
+  checks: readonly StupifyCheck[],
+  maxTargets: number,
+): readonly SemCandidate[] {
+  const buckets = runSignalCounters(changeSet, checks);
+  const targets: SemCandidate[] = [];
+  let cursor = 0;
+  while (targets.length < maxTargets && buckets.some((bucket) => cursor < bucket.examples.length)) {
+    for (const bucket of buckets) {
+      const signal = bucket.examples[cursor];
+      if (!signal) continue;
+      targets.push({
+        sourceId: changeSet.id,
+        targetId: `t${String(targets.length + 1).padStart(3, "0")}`,
+        entityId: signal.entityId,
+        checkId: signal.checkId,
+        reason: signal.reasonCode,
+      });
+      if (targets.length >= maxTargets) break;
+    }
+    cursor += 1;
+  }
+  return targets;
+}
+
+export function runSignalCounters(
+  changeSet: SemChangeSet,
+  checks: readonly StupifyCheck[],
+): readonly SignalBucket[] {
+  return checks
+    .map((check) => {
+      const signals = changeSet.changes.flatMap((change): readonly Signal[] => {
+        const reasonCode = reasonForCheck(check.id, change);
+        return reasonCode ? [{ checkId: check.id, entityId: change.entityId, reasonCode }] : [];
+      });
+      return {
+        checkId: check.id,
+        total: signals.length,
+        examples: signals.slice(0, MAX_COUNTER_EXAMPLES_PER_CHECK),
+      };
+    })
+    .filter((bucket) => bucket.total > 0);
+}
+
+function reasonForCheck(checkId: CheckId, change: SemChange): string | null {
+  if (!isSearchableSourceChange(change)) return null;
+
+  const haystack = `${change.entityName}\n${change.entityType}\n${change.filePath}\n${change.afterContent ?? ""}`.toLowerCase();
+  const changed = change.changeType === "added" || change.changeType === "modified";
+  if (!changed) return null;
+
+  switch (checkId as string) {
+    case "duplicated_schema":
+      return isDuplicatedSchemaCandidate(change) ? "local_schemaish_copy" : null;
+    case "unnecessary_complexity":
+      return /\b(helper|wrapper|service|provider|manager|factory|adapter|resolver|coordinator)\b/i.test(change.entityName)
+        ? "new_abstraction_name"
+        : null;
+    case "fake_precision_windowing":
+      return /\b(token|budget|window|batch|ratio|estimate|counter|count|limit)\b/i.test(haystack)
+        ? "precision_accounting_terms"
+        : null;
+    case "coauthored_slop":
+      return /\b(coauhtoried|coauthored|co-authored|co-authored-by)\b/i.test(haystack)
+        ? "coauthor_text"
+        : null;
+    case "mega_file":
+      return change.entityType === "chunk" && /lines\s+\d+-\d+/i.test(change.entityName)
+        ? "large_changed_chunk"
+        : null;
+    case "over_commenting":
+      return overCommentingSignal(change)
+        ? "comment_lines_increased"
+        : null;
+    case "lint_bypass":
+      return lintBypassSignal(change.afterContent ?? "")
+        ? "lint_or_type_bypass_text"
+        : null;
+    case "inconsistent_patterns":
+      return /\b(manager|factory|provider|adapter|orchestrator|coordinator)\b/i.test(change.entityName)
+        ? "pattern_abstraction_name"
+        : null;
+    case "reinvented_utils":
+      return reinventedUtilitySignal(change)
+        ? "generic_utility_name"
+        : null;
+    case "operator_style_mismatch":
+      return /\b(manager|factory|provider|enterprise|orchestrator)\b/i.test(haystack)
+        ? "style_smell_terms"
+        : null;
+    default:
+      return null;
+  }
+}
+
+function isDuplicatedSchemaCandidate(change: SemChange): boolean {
+  if (!/^(interface|type)$/i.test(change.entityType)) return false;
+  if (/^(public|external|internal|payment|.+client$)/i.test(change.entityName)) return false;
+  return /\b(local|payload|schema)\b/i.test(words(change.entityName));
+}
+
+function overCommentingSignal(change: SemChange): boolean {
+  const before = commentLines(change.beforeContent);
+  const after = commentLines(change.afterContent);
+  if (after <= before + 3) return false;
+  const comments = commentText(change.afterContent);
+  if (/\b(because|why|constraint|provider|external|api|quirk|edge case|timezone|utc|ledger|finance|reconciliation|rejects|mirrors|keep this)\b/i.test(comments)) {
+    return false;
+  }
+  return true;
+}
+
+function lintBypassSignal(value: string): boolean {
+  return value.split(/\r?\n/).some((line) => {
+    const trimmed = line.trim();
+    const comment = /^(\/\/|\/\*|\*)/.test(trimmed);
+    if (comment && /@ts-ignore\s*$/i.test(trimmed)) return true;
+    if (comment && /@ts-expect-error\s*$/i.test(trimmed)) return true;
+    if (comment && /(eslint-disable|biome-ignore)/i.test(trimmed) && !/\s--\s*\S/.test(trimmed)) return true;
+    return /\bas unknown as\b|\bas any\b|:\s*any\b/i.test(trimmed);
+  });
+}
+
+function reinventedUtilitySignal(change: SemChange): boolean {
+  const name = change.entityName;
+  if (!/^(clamp|debounce|throttle|slug|slugify|group|sort|shuffle|memoize|pick|omit|uniq)/i.test(name)) return false;
+  const content = change.afterContent ?? "";
+  if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`)) return false;
+  return true;
+}
+
+function isSearchableSourceChange(change: SemChange): boolean {
+  const filePath = change.filePath.toLowerCase();
+  if (/(^|\/)(bun|package-lock|pnpm-lock|yarn)\.lock$/.test(filePath)) return false;
+  if (/(^|\/)(dist|build|coverage|generated|vendor|fixtures?|snapshots?)(\/|$)/.test(filePath)) return false;
+  if (/\.(md|mdx|txt|json|jsonc|ya?ml|toml|lock|csv|svg|png|jpe?g|gif|webp)$/i.test(filePath)) return false;
+  if (/\.(test|spec|fixture)\.[cm]?[jt]sx?$/i.test(filePath)) return false;
+  return /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/i.test(filePath);
+}
+
+function commentLines(value: string | null): number {
+  if (!value) return 0;
+  return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
+}
+
+function commentText(value: string | null): string {
+  if (!value) return "";
+  return value
+    .split(/\r?\n/)
+    .filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line))
+    .join("\n");
+}
+
+function words(value: string): string {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ");
+}

package/src/diff.ts

@@ -0,0 +1,9 @@
+import { stdin as input } from "node:process";
+
+export async function readDiffFromStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of input) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text.trim()) throw new Error("No diff received on stdin.");
+  return text;
+}