cue-ai 0.5.0 → 0.7.0

package/src/commands/discover.scoring.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Scorer regression fixtures for `cue discover`.
+ *
+ * Each case is hand-labeled with a known-good repo (or known dump). We assert
+ * on a *range*, not an exact value — the scoring formula is allowed to drift,
+ * but real gems must stay well above the default --min-score (3) and dumps
+ * must stay at 0.
+ *
+ * If you tweak the formula in discover.ts and these break: re-rank the
+ * fixtures by hand first, then adjust the ranges here.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { scoreGem, isLikelySpam, type GemRepo } from "./discover";
+
+// ---- Fixture helpers ------------------------------------------------------
+
+const DAY = 86_400_000;
+const iso = (daysAgo: number) => new Date(Date.now() - daysAgo * DAY).toISOString();
+
+function gem(partial: Partial<GemRepo>): GemRepo {
+  return {
+    full_name: "",
+    owner: "",
+    name: "",
+    description: "",
+    stars: 0,
+    forks: 0,
+    created_at: iso(180),
+    pushed_at: iso(7),
+    topics: [],
+    language: "",
+    has_skill_md: false,
+    has_claude_dir: false,
+    has_mcp_sdk: false,
+    gem_score: 0,
+    suggested_profiles: [],
+    suggested_mcps: [],
+    suggested_clis: [],
+    quality: 0,
+    url: "",
+    ...partial,
+  };
+}
+
+// ---- Real-world labeled fixtures -----------------------------------------
+
+const FIXTURES: Array<{ label: string; repo: GemRepo; min: number; max: number; spam?: boolean }> = [
+  {
+    label: "elementalsouls/Claude-OSINT — 1362★ curated, top-tier gem",
+    repo: gem({
+      owner: "elementalsouls", name: "Claude-OSINT",
+      description: "Two paired Claude skills · 90+ recon modules · 48 secret-regex patterns · 80+ dorks",
+      stars: 1362, forks: 120, created_at: iso(365), pushed_at: iso(7),
+      topics: ["claude-skill", "mcp-server"], language: "Python",
+      has_skill_md: true, has_claude_dir: true,
+    }),
+    min: 18, max: 30,
+  },
+  {
+    label: "fallow-rs/fallow-skills — 48★ proven small skill repo",
+    repo: gem({
+      owner: "fallow-rs", name: "fallow-skills",
+      description: "Agent skills for fallow, codebase intelligence for JavaScript and TypeScript",
+      stars: 48, forks: 6, created_at: iso(60), pushed_at: iso(7),
+      topics: ["agent-skill"], language: "Rust",
+      has_skill_md: true,
+    }),
+    min: 10, max: 18,
+  },
+  {
+    label: "Lupynow/math-modeling-skills — 21★ mature & active",
+    repo: gem({
+      owner: "Lupynow", name: "math-modeling-skills",
+      description: "Math modeling competition guidance Skill — covers CUMCM and MCM/ICM",
+      stars: 21, forks: 3, created_at: iso(365), pushed_at: iso(30),
+      topics: ["claude-skill"], language: "Python",
+      has_skill_md: true,
+    }),
+    min: 9, max: 16,
+  },
+  {
+    label: "Zandereins/hydra — 1★ hydra council, has SKILL.md, fresh",
+    repo: gem({
+      owner: "Zandereins", name: "hydra",
+      description: "Multi-perspective code review council for Claude Code. 3 advisors by default, 10 agents in deep mode",
+      stars: 1, forks: 0, created_at: iso(30), pushed_at: iso(7),
+      topics: ["claude-skill"], language: "TypeScript",
+      has_skill_md: true,
+    }),
+    min: 8, max: 14,
+  },
+
+  // --- Spam / AI dumps ---
+  {
+    label: "ditakebede1/personal-knowledge-nexus — AI slop (Library OS opener)",
+    repo: gem({
+      owner: "ditakebede1", name: "personal-knowledge-nexus",
+      description: "Library OS 2026: Auto-Publish Your Deep Book Notes to Your Website",
+      stars: 0, forks: 0, created_at: iso(7), pushed_at: iso(7),
+    }),
+    min: 0, max: 0, spam: true,
+  },
+  {
+    label: "Meizu1330/neural-context-archive — AI slop (year-stamped name)",
+    repo: gem({
+      owner: "Meizu1330", name: "neural-context-archive-2026",
+      description: "GitHub Memory Snapshot 2026 – Auto Recall & Prune Project Context",
+      stars: 0, forks: 0, created_at: iso(7), pushed_at: iso(7),
+    }),
+    min: 0, max: 0, spam: true,
+  },
+  {
+    label: "j28rawat/support-sentinel — AI slop (Production-grade opener)",
+    repo: gem({
+      owner: "j28rawat", name: "support-sentinel",
+      description: "Production-grade multi-agent AI customer support system",
+      stars: 0, forks: 0, created_at: iso(5), pushed_at: iso(5),
+    }),
+    min: 0, max: 0, spam: true,
+  },
+
+  // --- Edge cases ---
+  {
+    label: "Edge: fresh repo with year-stamped name BUT has SKILL.md → not spam",
+    repo: gem({
+      owner: "real-author", name: "skill-2026",
+      description: "",
+      stars: 0, forks: 0, created_at: iso(7), pushed_at: iso(7),
+      has_skill_md: true,
+    }),
+    min: 5, max: 12, spam: false,
+  },
+  {
+    label: "Edge: stale repo (push 500d ago) — penalty applies, low but nonzero",
+    repo: gem({
+      owner: "abandoned", name: "old-skill",
+      description: "An older skill that used to work great — long since unmaintained",
+      stars: 5, forks: 1, created_at: iso(700), pushed_at: iso(500),
+      has_skill_md: true,
+    }),
+    min: 2, max: 7,
+  },
+  {
+    label: "Edge: just an MCP SDK user, no SKILL.md — modest signal",
+    repo: gem({
+      owner: "someone", name: "mcp-tool",
+      description: "Tiny MCP server for X — uses the model context protocol SDK",
+      stars: 3, forks: 0, created_at: iso(120), pushed_at: iso(20),
+      has_mcp_sdk: true,
+    }),
+    min: 3, max: 8,
+  },
+];
+
+// ---- Tests ----------------------------------------------------------------
+
+describe("scoreGem — labeled real-world fixtures", () => {
+  for (const fx of FIXTURES) {
+    test(fx.label, () => {
+      const score = scoreGem(fx.repo);
+      expect(score).toBeGreaterThanOrEqual(fx.min);
+      expect(score).toBeLessThanOrEqual(fx.max);
+      if (fx.spam !== undefined) {
+        expect(isLikelySpam(fx.repo)).toBe(fx.spam);
+      }
+    });
+  }
+});
+
+describe("scoreGem — ordering invariants", () => {
+  test("curated 1000★ repo outranks 1★ fresh repo (both have SKILL.md)", () => {
+    const curated = FIXTURES.find(f => f.label.startsWith("elementalsouls"))!.repo;
+    const fresh = FIXTURES.find(f => f.label.startsWith("Zandereins"))!.repo;
+    expect(scoreGem(curated)).toBeGreaterThan(scoreGem(fresh));
+  });
+
+  test("any AI dump scores below the default --min-score=3", () => {
+    for (const fx of FIXTURES.filter(f => f.spam === true)) {
+      expect(scoreGem(fx.repo)).toBeLessThan(3);
+    }
+  });
+
+  test("SKILL.md is the load-bearing signal: adding it lifts an otherwise-borderline repo", () => {
+    const without = gem({
+      owner: "x", name: "y", description: "Reasonable description of an MCP server here",
+      stars: 5, forks: 0, created_at: iso(100), pushed_at: iso(20),
+    });
+    const withIt = { ...without, has_skill_md: true };
+    // Allow tiny fp epsilon; the contract is "SKILL.md contributes the full +5 bonus".
+    expect(scoreGem(withIt) - scoreGem(without)).toBeGreaterThan(4.95);
+  });
+});
+
+describe("isLikelySpam — guard conditions", () => {
+  test("does NOT mark spam if has_skill_md is true (load-bearing exemption)", () => {
+    expect(isLikelySpam(gem({
+      owner: "spammy1", name: "foo-2026", description: "",
+      created_at: iso(2), has_skill_md: true,
+    }))).toBe(false);
+  });
+
+  test("does NOT mark spam if repo has any engagement (forks ≥ 1)", () => {
+    expect(isLikelySpam(gem({
+      owner: "spammy1", name: "foo-2026", description: "",
+      stars: 0, forks: 1, created_at: iso(2),
+    }))).toBe(false);
+  });
+
+  test("does NOT mark spam if repo is older than 14 days", () => {
+    expect(isLikelySpam(gem({
+      owner: "spammy1", name: "foo-2026", description: "",
+      stars: 0, forks: 0, created_at: iso(30),
+    }))).toBe(false);
+  });
+});

package/src/commands/discover.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Tests for `cue discover` export modes. Writes a synthetic gems cache, runs
+ * the command against a tmp dir, and asserts on the file shape. No network.
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, readdirSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join } from "node:path";
+
+import { run as discoverRun } from "./discover";
+
+let tmp: string;
+let originalXdg: string | undefined;
+
+beforeEach(() => {
+  tmp = `${tmpdir()}/cue-discover-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  mkdirSync(tmp, { recursive: true });
+  // Redirect XDG_CONFIG_HOME so the cache lives in tmp and we don't trample the user's real cache.
+  originalXdg = process.env.XDG_CONFIG_HOME;
+  process.env.XDG_CONFIG_HOME = join(tmp, "config");
+
+  // Seed a synthetic gem cache the export command will consume.
+  const cacheDir = join(tmp, "config", "cue", "discover");
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(join(cacheDir, "gems.json"), JSON.stringify({
+    updated: "2026-05-24T00:00:00.000Z",
+    gems: [
+      {
+        full_name: "octocat/alpha", owner: "octocat", name: "alpha",
+        description: "Alpha skill for backend devs.", stars: 12, forks: 1,
+        created_at: "2026-01-01", pushed_at: "2026-05-01",
+        topics: ["claude-skill"], language: "TypeScript",
+        has_skill_md: true, has_claude_dir: false, has_mcp_sdk: false,
+        gem_score: 9, suggested_profiles: ["backend"], suggested_mcps: [], suggested_clis: ["node"],
+        quality: 8, url: "https://github.com/octocat/alpha",
+      },
+      {
+        full_name: "octocat/beta", owner: "octocat", name: "beta",
+        description: "Beta skill for marketing folks.", stars: 4, forks: 0,
+        created_at: "2026-02-01", pushed_at: "2026-05-10",
+        topics: [], language: "JavaScript",
+        has_skill_md: true, has_claude_dir: false, has_mcp_sdk: false,
+        gem_score: 6, suggested_profiles: ["marketing", "backend"], suggested_mcps: [], suggested_clis: [],
+        quality: 5, url: "https://github.com/octocat/beta",
+      },
+    ],
+  }, null, 2));
+});
+
+afterEach(() => {
+  if (originalXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = originalXdg;
+  try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+});
+
+// Silence stdout in tests
+function silent<T>(fn: () => Promise<T>): Promise<T> {
+  const orig = process.stdout.write.bind(process.stdout);
+  (process.stdout as any).write = () => true;
+  return fn().finally(() => { (process.stdout as any).write = orig; });
+}
+
+describe("cue discover --export (legacy single-file)", () => {
+  test("writes a single markdown file with both gems grouped by profile", async () => {
+    const out = join(tmp, "out.md");
+    await silent(() => discoverRun(["--export", out]));
+    expect(existsSync(out)).toBe(true);
+    const content = readFileSync(out, "utf8");
+    expect(content).toMatch(/# 🎯 Discovered Skills/);
+    expect(content).toContain("octocat/alpha");
+    expect(content).toContain("octocat/beta");
+    expect(content).toMatch(/^##\s.*backend/m);
+    expect(content).toMatch(/^##\s.*marketing/m);
+  });
+});
+
+describe("cue discover --export --site (per-profile pages)", () => {
+  test("emits index + per-profile pages with frontmatter", async () => {
+    const dir = join(tmp, "site");
+    await silent(() => discoverRun(["--export", dir, "--site"]));
+
+    expect(existsSync(join(dir, "index.md"))).toBe(true);
+    expect(existsSync(join(dir, "backend.md"))).toBe(true);
+    expect(existsSync(join(dir, "marketing.md"))).toBe(true);
+
+    const indexMd = readFileSync(join(dir, "index.md"), "utf8");
+    expect(indexMd).toMatch(/^---\n/);                    // frontmatter
+    expect(indexMd).toMatch(/title: "Discovered/);
+    expect(indexMd).toContain("[**backend**](./backend.md)");
+    expect(indexMd).toContain("[**marketing**](./marketing.md)");
+
+    const backendMd = readFileSync(join(dir, "backend.md"), "utf8");
+    expect(backendMd).toMatch(/title: "Claude Code Skills for backend"/);
+    expect(backendMd).toContain("octocat/alpha");
+    expect(backendMd).toContain("octocat/beta");           // beta also fits backend
+    expect(backendMd).toContain("cue skills add octocat/alpha --profile backend");
+    expect(backendMd).toMatch(/<a id="octocat-alpha"><\/a>/);  // stable per-repo anchor
+  });
+
+  test("--site --html also emits .html files with JSON-LD schema", async () => {
+    const dir = join(tmp, "site-html");
+    await silent(() => discoverRun(["--export", dir, "--site", "--html"]));
+
+    expect(existsSync(join(dir, "index.html"))).toBe(true);
+    expect(existsSync(join(dir, "backend.html"))).toBe(true);
+
+    const indexHtml = readFileSync(join(dir, "index.html"), "utf8");
+    expect(indexHtml).toContain('application/ld+json');
+    expect(indexHtml).toContain('"@type": "ItemList"');
+    expect(indexHtml).toContain('"@type": "SoftwareApplication"');
+    expect(indexHtml).toContain('"name": "octocat/alpha"');
+    expect(indexHtml).toContain('property="og:title"');     // social meta
+    expect(indexHtml).toContain('rel="canonical"');         // SEO canonical
+
+    const backendHtml = readFileSync(join(dir, "backend.html"), "utf8");
+    expect(backendHtml).toContain('Claude Code Skills for backend');
+    expect(backendHtml).toContain('id="octocat-alpha"');    // anchor for deep-links
+  });
+
+  test("total file count matches: 1 index + N profiles (× 2 if html)", async () => {
+    const dir = join(tmp, "site-count");
+    await silent(() => discoverRun(["--export", dir, "--site", "--html"]));
+    const files = readdirSync(dir);
+    // 1 (index) + 2 (backend, marketing) = 3, times 2 for html = 6
+    expect(files.filter((f) => f.endsWith(".md")).length).toBe(3);
+    expect(files.filter((f) => f.endsWith(".html")).length).toBe(3);
+  });
+});
+
+describe("cue discover --export with missing cache", () => {
+  test("exits 1 with helpful error", async () => {
+    rmSync(join(tmp, "config", "cue", "discover", "gems.json"));
+    const origErr = process.stderr.write.bind(process.stderr);
+    let stderr = "";
+    (process.stderr as any).write = (c: string | Uint8Array) => { stderr += String(c); return true; };
+    try {
+      const code = await silent(() => discoverRun(["--export", join(tmp, "out.md")]));
+      expect(code).toBe(1);
+      expect(stderr).toContain("No cached gems");
+    } finally {
+      (process.stderr as any).write = origErr;
+    }
+  });
+});