Merge pull request #30 from ravidsrk/ravidsrk/slop-detect-w2a-core

refactor(core): migrate to @slop-detect/core (tsup + vitest + composite tsconfig)

Author: ravidsrk

bun.lock

@@ -32,7 +32,7 @@
     "demo": "node dist/bin/slop.js https://news.ycombinator.com https://www.aura.build https://lovable.dev"
   },
   "dependencies": {
-    "slop-detect-core": "0.7.0",
+    "@slop-detect/core": "workspace:*",
     "playwright": "^1.49.0"
   },
   "keywords": [

packages/cli/package.json

@@ -0,0 +1,4 @@
+dist/
+coverage/
+.turbo/
+*.tsbuildinfo

packages/core/.gitignore

@@ -1,6 +1,6 @@
 {
-  "name": "slop-detect-core",
-  "version": "0.7.0",
+  "name": "@slop-detect/core",
+  "version": "0.8.0",
   "description": "Pure detection engine for AI-design-slop patterns. Runtime-agnostic — runs in Node, Cloudflare Workers, or the browser.",
   "type": "module",
   "license": "MIT",
@@ -10,50 +10,32 @@
     "url": "git+https://github.com/ravidsrk/slop-detect.git",
     "directory": "packages/core"
   },
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./patterns": {
-      "types": "./dist/patterns.d.ts",
-      "default": "./dist/patterns.js"
-    },
-    "./fonts": {
-      "types": "./dist/fonts.d.ts",
-      "default": "./dist/fonts.js"
-    },
-    "./color": {
-      "types": "./dist/color.d.ts",
-      "default": "./dist/color.js"
-    },
-    "./visibility": {
-      "types": "./dist/visibility.d.ts",
-      "default": "./dist/visibility.js"
-    },
-    "./fixes": {
-      "types": "./dist/fixes.d.ts",
-      "default": "./dist/fixes.js"
-    },
-    "./aeo": {
-      "types": "./dist/aeo.d.ts",
-      "default": "./dist/aeo.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "prepack": "tsc"
+    "clean": "rm -rf dist .turbo"
   },
   "files": [
     "dist",
-    "src",
     "README.md",
-    "LICENSE",
-    "NOTICE"
+    "LICENSE"
   ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "slop",
     "ai-detection",

packages/core/package.json

@@ -1,78 +1,77 @@
 // Unit tests for the AEO axis. Pure functions + an injected fetch mock so the
 // check runner is fully deterministic (no network). Run with:
-//   node --test packages/core/test/aeo.test.js
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
+//   vitest run packages/core/test/aeo.test.js
+import { test, expect } from 'vitest';
 import {
   AI_BOTS,
   AEO_CHECKS,
   detectAIBot,
   aiBotsBlockedByRobots,
   toMarkdownUrl,
   runAeoChecks,
-} from '../src/aeo.js';
+} from '@slop-detect/core';
 
 // ── detectAIBot ──────────────────────────────────────────────────────────────
 test('detectAIBot identifies known crawlers by substring, case-insensitive', () => {
   const gpt = detectAIBot('Mozilla/5.0 (compatible; GPTBot/1.2; +https://openai.com/gptbot)');
-  assert.equal(gpt.isBot, true);
-  assert.equal(gpt.vendor, 'OpenAI');
-  assert.equal(gpt.purpose, 'training');
+  expect(gpt.isBot).toBe(true);
+  expect(gpt.vendor).toBe('OpenAI');
+  expect(gpt.purpose).toBe('training');
 
   const claude = detectAIBot('claudebot/1.0');
-  assert.equal(claude.isBot, true);
-  assert.equal(claude.vendor, 'Anthropic');
+  expect(claude.isBot).toBe(true);
+  expect(claude.vendor).toBe('Anthropic');
 
   const human = detectAIBot('Mozilla/5.0 (Macintosh) Safari/605');
-  assert.equal(human.isBot, false);
-  assert.equal(human.vendor, null);
+  expect(human.isBot).toBe(false);
+  expect(human.vendor).toBe(null);
 
-  assert.equal(detectAIBot('').isBot, false);
+  expect(detectAIBot('').isBot).toBe(false);
 });
 
 test('AI_BOTS registry is non-trivial and covers the big four vendors', () => {
-  assert.ok(AI_BOTS.length >= 20, `expected a substantial registry, got ${AI_BOTS.length}`);
+  expect(AI_BOTS.length >= 20).toBeTruthy();
   const vendors = new Set(AI_BOTS.map((b) => b.vendor));
   for (const v of ['OpenAI', 'Anthropic', 'Perplexity', 'Google']) {
-    assert.ok(vendors.has(v), `registry missing ${v}`);
+    expect(vendors.has(v)).toBeTruthy();
   }
 });
 
 // ── toMarkdownUrl ────────────────────────────────────────────────────────────
 test('toMarkdownUrl maps pages to their .md twin', () => {
-  assert.equal(toMarkdownUrl('https://x.com/blog/post'), 'https://x.com/blog/post.md');
-  assert.equal(toMarkdownUrl('https://x.com/'), 'https://x.com/index.md');
-  assert.equal(toMarkdownUrl('https://x.com/a/'), 'https://x.com/a.md');
+  expect(toMarkdownUrl('https://x.com/blog/post')).toBe('https://x.com/blog/post.md');
+  expect(toMarkdownUrl('https://x.com/')).toBe('https://x.com/index.md');
+  expect(toMarkdownUrl('https://x.com/a/')).toBe('https://x.com/a.md');
   // idempotent
-  assert.equal(toMarkdownUrl('https://x.com/a.md'), 'https://x.com/a.md');
+  expect(toMarkdownUrl('https://x.com/a.md')).toBe('https://x.com/a.md');
 });
 
 // ── robots.txt parser ────────────────────────────────────────────────────────
 test('aiBotsBlockedByRobots: blanket Disallow under * blocks AI bots', () => {
   const r = aiBotsBlockedByRobots('User-agent: *\nDisallow: /', '/blog');
-  assert.equal(r.blocked, true);
-  assert.deepEqual(r.agents, ['*']);
+  expect(r.blocked).toBe(true);
+  expect(r.agents).toEqual(['*']);
 });
 
 test('aiBotsBlockedByRobots: named AI bot disallow is detected', () => {
   const r = aiBotsBlockedByRobots(
     'User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow:',
     '/'
   );
-  assert.equal(r.blocked, true);
-  assert.ok(r.agents.includes('gptbot'));
+  expect(r.blocked).toBe(true);
+  expect(r.agents.includes('gptbot')).toBeTruthy();
 });
 
 test('aiBotsBlockedByRobots: empty Disallow and unrelated bots do not block', () => {
-  assert.equal(aiBotsBlockedByRobots('User-agent: *\nDisallow:', '/').blocked, false);
-  assert.equal(aiBotsBlockedByRobots('User-agent: AhrefsBot\nDisallow: /', '/').blocked, false);
-  assert.equal(aiBotsBlockedByRobots('', '/').blocked, false);
+  expect(aiBotsBlockedByRobots('User-agent: *\nDisallow:', '/').blocked).toBe(false);
+  expect(aiBotsBlockedByRobots('User-agent: AhrefsBot\nDisallow: /', '/').blocked).toBe(false);
+  expect(aiBotsBlockedByRobots('', '/').blocked).toBe(false);
 });
 
 test('aiBotsBlockedByRobots: path-scoped disallow only blocks matching paths', () => {
   const robots = 'User-agent: *\nDisallow: /admin';
-  assert.equal(aiBotsBlockedByRobots(robots, '/admin/users').blocked, true);
-  assert.equal(aiBotsBlockedByRobots(robots, '/blog/post').blocked, false);
+  expect(aiBotsBlockedByRobots(robots, '/admin/users').blocked).toBe(true);
+  expect(aiBotsBlockedByRobots(robots, '/blog/post').blocked).toBe(false);
 });
 
 // ── runAeoChecks with an injected fetch mock ─────────────────────────────────
@@ -115,14 +114,10 @@ test('runAeoChecks: fully AEO-ready site scores AI-Ready (100)', async () => {
   });
 
   const r = await runAeoChecks('https://ready.example', { fetchImpl, timeoutMs: 1000 });
-  assert.equal(r.axis, 'aeo');
-  assert.equal(
-    r.score,
-    100,
-    `expected perfect, got ${r.score}: ${JSON.stringify(r.failed.map((c) => c.id))}`
-  );
-  assert.equal(r.tier, 'AI-Ready');
-  assert.equal(r.requiredFailed, 0);
+  expect(r.axis).toBe('aeo');
+  expect(r.score).toBe(100);
+  expect(r.tier).toBe('AI-Ready');
+  expect(r.requiredFailed).toBe(0);
 });
 
 test('runAeoChecks: site that blocks GPTBot + has noindex fails the required checks', async () => {
@@ -142,14 +137,14 @@ test('runAeoChecks: site that blocks GPTBot + has noindex fails the required che
 
   const r = await runAeoChecks('https://blocked.example', { fetchImpl, timeoutMs: 1000 });
   const failedIds = new Set(r.failed.map((c) => c.id));
-  assert.ok(failedIds.has('bot.notBlocked'), 'should flag blocked GPTBot');
-  assert.ok(failedIds.has('robots.aiAllowed'), 'should flag robots disallow');
-  assert.ok(failedIds.has('html.indexable'), 'should flag noindex');
-  assert.ok(r.requiredFailed >= 3);
-  assert.equal(r.tier, 'Invisible');
+  expect(failedIds.has('bot.notBlocked')).toBeTruthy();
+  expect(failedIds.has('robots.aiAllowed')).toBeTruthy();
+  expect(failedIds.has('html.indexable')).toBeTruthy();
+  expect(r.requiredFailed >= 3).toBeTruthy();
+  expect(r.tier).toBe('Invisible');
 });
 
 test('AEO_CHECKS weights total 100', () => {
   const total = AEO_CHECKS.reduce((s, c) => s + c.weight, 0);
-  assert.equal(total, 100);
+  expect(total).toBe(100);
 });

packages/core/test/aeo.test.js

@@ -2,9 +2,8 @@
 // when given an isUrlAllowed hook, so a public URL can't bounce the fetcher to
 // an internal host.
 
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { runAeoChecks } from '../src/aeo.js';
+import { test, expect } from 'vitest';
+import { runAeoChecks } from '@slop-detect/core';
 
 // A fetch mock that 302-redirects the main page to cloud-metadata, and returns
 // a benign 200 for everything else (robots/llms/md/etc.).
@@ -31,10 +30,10 @@ test('runAeoChecks blocks a redirect to an internal host (no internal fetch)', a
     timeoutMs: 2000,
   });
   // The internal metadata host must never have been fetched.
-  assert.ok(!seen.some((u) => u.includes('169.254.169.254')), 'must not fetch the internal host');
+  expect(seen.some((u) => u.includes('169.254.169.254'))).toBe(false);
   // And the reachability check should have failed (blocked), not silently passed.
   const reachable = report.checks.find((c) => c.id === 'html.reachable');
-  assert.equal(reachable.passed, false, 'blocked redirect → not reachable');
+  expect(reachable.passed).toBe(false);
 });
 
 test('without isUrlAllowed, behavior is unchanged (auto-follow)', async () => {
@@ -45,5 +44,5 @@ test('without isUrlAllowed, behavior is unchanged (auto-follow)', async () => {
       headers: { 'content-type': 'text/html' },
     });
   const report = await runAeoChecks('https://ok.example/', { fetchImpl, timeoutMs: 2000 });
-  assert.equal(report.checks.find((c) => c.id === 'html.reachable').passed, true);
+  expect(report.checks.find((c) => c.id === 'html.reachable').passed).toBe(true);
 });

packages/core/test/aeo_ssrf.test.js

@@ -5,9 +5,9 @@
 // createColorHelpers() builds a <canvas> at construction (for parseColor), so we
 // stub a minimal document. The math functions under test never touch the canvas.
 //
-// Run with: node --test packages/core/test/color.test.js
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
+// Run with: vitest run packages/core/test/color.test.js
+import { test, expect } from 'vitest';
+import { createColorHelpers } from '@slop-detect/core';
 
 // Minimal DOM stub so createColorHelpers() can construct.
 globalThis.document = {
@@ -26,47 +26,46 @@ globalThis.document = {
   }),
 };
 
-const { createColorHelpers } = await import('../src/color.js');
 const h = createColorHelpers();
 
 const WHITE = { r: 255, g: 255, b: 255, a: 1 };
 const BLACK = { r: 0, g: 0, b: 0, a: 1 };
 
 test('relativeLuminance: black is 0, white is 1', () => {
-  assert.equal(h.relativeLuminance(BLACK), 0);
-  assert.ok(Math.abs(h.relativeLuminance(WHITE) - 1) < 1e-9);
+  expect(h.relativeLuminance(BLACK)).toBe(0);
+  expect(Math.abs(h.relativeLuminance(WHITE) - 1) < 1e-9).toBeTruthy();
 });
 
 test('contrastRatio: black-on-white is 21:1', () => {
-  assert.ok(Math.abs(h.contrastRatio(BLACK, WHITE) - 21) < 0.01);
-  assert.equal(h.contrastRatio(WHITE, WHITE), 1); // identical = 1:1
+  expect(Math.abs(h.contrastRatio(BLACK, WHITE) - 21) < 0.01).toBeTruthy();
+  expect(h.contrastRatio(WHITE, WHITE)).toBe(1); // identical = 1:1
 });
 
 test('contrastRatio: known WCAG pair #767676 on white ≈ 4.54:1 (AA body pass)', () => {
   const grey = { r: 0x76, g: 0x76, b: 0x76, a: 1 };
   const ratio = h.contrastRatio(grey, WHITE);
-  assert.ok(ratio >= 4.5 && ratio < 4.6, `expected ~4.54, got ${ratio}`);
+  expect(ratio >= 4.5 && ratio < 4.6).toBeTruthy();
 });
 
 test('contrastRatio: light grey #aaa on white fails AA body (< 4.5)', () => {
   const lightGrey = { r: 0xaa, g: 0xaa, b: 0xaa, a: 1 };
-  assert.ok(h.contrastRatio(lightGrey, WHITE) < 4.5);
+  expect(h.contrastRatio(lightGrey, WHITE) < 4.5).toBeTruthy();
 });
 
 test('channelSpread: greys are ~0, saturated colors are high', () => {
-  assert.equal(h.channelSpread({ r: 128, g: 128, b: 128 }), 0);
-  assert.equal(h.channelSpread({ r: 99, g: 102, b: 241 }), 142); // indigo-500
+  expect(h.channelSpread({ r: 128, g: 128, b: 128 })).toBe(0);
+  expect(h.channelSpread({ r: 99, g: 102, b: 241 })).toBe(142); // indigo-500
 });
 
 test('isNeutral: greys/black/white neutral, saturated not', () => {
-  assert.equal(h.isNeutral({ r: 128, g: 130, b: 132, a: 1 }), true); // spread 4
-  assert.equal(h.isNeutral(WHITE), true);
-  assert.equal(h.isNeutral({ r: 0, g: 0, b: 0, a: 0 }), true); // transparent
-  assert.equal(h.isNeutral({ r: 99, g: 102, b: 241, a: 1 }), false); // indigo
-  assert.equal(h.isNeutral({ r: 200, g: 200, b: 160, a: 1 }), false); // spread 40 — tinted
+  expect(h.isNeutral({ r: 128, g: 130, b: 132, a: 1 })).toBe(true); // spread 4
+  expect(h.isNeutral(WHITE)).toBe(true);
+  expect(h.isNeutral({ r: 0, g: 0, b: 0, a: 0 })).toBe(true); // transparent
+  expect(h.isNeutral({ r: 99, g: 102, b: 241, a: 1 })).toBe(false); // indigo
+  expect(h.isNeutral({ r: 200, g: 200, b: 160, a: 1 })).toBe(false); // spread 40 — tinted
 });
 
 test('isNeutral: spread exactly at 30 boundary is NOT neutral', () => {
-  assert.equal(h.isNeutral({ r: 100, g: 100, b: 130, a: 1 }), false); // spread 30
-  assert.equal(h.isNeutral({ r: 100, g: 100, b: 129, a: 1 }), true); // spread 29
+  expect(h.isNeutral({ r: 100, g: 100, b: 130, a: 1 })).toBe(false); // spread 30
+  expect(h.isNeutral({ r: 100, g: 100, b: 129, a: 1 })).toBe(true); // spread 29
 });