@grove-dev/astro 0.7.0 → 0.9.0

package/src/server/github-repo.test.ts

@@ -1,88 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { fetchRepoMetadata } from './github-repo.js';
-
-const originalFetch = globalThis.fetch;
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  vi.restoreAllMocks();
-});
-
-describe('fetchRepoMetadata', () => {
-  it('returns 400 for invalid owner names', async () => {
-    const result = await fetchRepoMetadata({ owner: '../etc', repo: 'passwd' });
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.status).toBe(400);
-  });
-
-  it('returns 400 for invalid repo names', async () => {
-    const result = await fetchRepoMetadata({ owner: 'owner', repo: 'bad name' });
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.status).toBe(400);
-  });
-
-  it('returns the parsed repo on a 200 response', async () => {
-    globalThis.fetch = vi.fn(
-      async () =>
-        new Response(
-          JSON.stringify({
-            name: 'demo',
-            description: 'desc',
-            html_url: 'https://github.com/owner/demo',
-            homepage: 'https://demo.example',
-            language: 'TypeScript',
-            private: false,
-            topics: ['x', 'y'],
-          }),
-          { status: 200 },
-        ),
-    );
-    const result = await fetchRepoMetadata({ owner: 'owner', repo: 'demo' });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.data.name).toBe('demo');
-      expect(result.data.html_url).toBe('https://github.com/owner/demo');
-      expect(result.data.topics).toEqual(['x', 'y']);
-    }
-  });
-
-  it('forwards an Authorization header when a token is provided', async () => {
-    const spy = vi.fn(async () => new Response('{}', { status: 200 }));
-    globalThis.fetch = spy;
-    await fetchRepoMetadata({ owner: 'owner', repo: 'demo', token: 'gh_test_123' });
-    const headers = spy.mock.calls[0]?.[1]?.headers as Record<string, string>;
-    expect(headers.Authorization).toBe('Bearer gh_test_123');
-  });
-
-  it('maps a 404 to a structured error', async () => {
-    globalThis.fetch = vi.fn(async () => new Response('not found', { status: 404 }));
-    const result = await fetchRepoMetadata({ owner: 'owner', repo: 'missing' });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(404);
-      expect(result.message).toMatch(/not found/i);
-    }
-  });
-
-  it('maps a 403 to a rate-limit error', async () => {
-    globalThis.fetch = vi.fn(async () => new Response('forbidden', { status: 403 }));
-    const result = await fetchRepoMetadata({ owner: 'owner', repo: 'demo' });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(403);
-      expect(result.message).toMatch(/rate limit/i);
-    }
-  });
-
-  it('maps network errors to a 502', async () => {
-    globalThis.fetch = vi.fn(async () => {
-      throw new Error('ECONNRESET');
-    });
-    const result = await fetchRepoMetadata({ owner: 'owner', repo: 'demo' });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(502);
-      expect(result.message).toBe('ECONNRESET');
-    }
-  });
-});

package/src/server/models-home.test.ts

@@ -1,101 +0,0 @@
-/**
- * Real-module tests for `getHomePageModel` — the homepage stack/category
- * count block.
- *
- * `models.ts` transitively imports `@grove/generated/*.json` at module
- * load, so (like `directory.test.ts`) we mock those build artifacts to
- * import the actual implementation instead of re-deriving it.
- *
- * Regression coverage for the audit's "Python 3 vs 4" drift: the count
- * block used to iterate `fullItems` (every record, hidden included)
- * and count only the singular `record.stack`, while browse filtered the
- * visible index by the primary+supporting union. The fix counts the
- * visible `items` via `projectStackIds`.
- */
-import { describe, expect, it, vi } from "vitest";
-
-function indexRecord(
-  slug: string,
-  options: { stack?: string; stacks?: string[]; category?: string } = {},
-) {
-  return {
-    kind: "project",
-    slug,
-    name: slug,
-    description: `${slug} description`,
-    category: options.category ?? "tools",
-    tags: [],
-    stack: options.stack ?? options.stacks?.[0],
-    stacks: options.stacks ?? [],
-    platforms: ["linux"],
-    projectType: "real-app",
-    bestFor: [],
-    whyListed: [],
-    caveats: [],
-    links: {},
-    distribution: { channels: [] },
-    source: { type: "manual" },
-    curation: { reviewed: true, labels: [], lenses: [] },
-    visibility: "keep",
-  };
-}
-
-// The generated index payload is visible-only by contract; the hidden
-// record exists ONLY in the full payload. If the model ever goes back
-// to counting `fullItems`, the hidden "rust" stack would reappear.
-const visible = [
-  indexRecord("a", { stacks: ["python"] }),
-  indexRecord("b", { stacks: ["python", "go"] }),
-  indexRecord("c", { stacks: ["typescript"] }),
-  // Primary diverges from supporting (the open-webui shape): must
-  // count as python via the union.
-  indexRecord("d", { stack: "typescript", stacks: ["typescript", "python"] }),
-];
-const hidden = { ...indexRecord("ghost", { stacks: ["rust"] }), visibility: "hide" };
-
-vi.mock("@grove/generated/records.full.json", () => ({
-  default: { records: [...visible, hidden] },
-}));
-vi.mock("@grove/generated/records.index.json", () => ({ default: { records: visible } }));
-vi.mock("@grove/generated/site-config.json", () => ({ default: {} }));
-
-const { getHomePageModel } = await import("./models.js");
-
-const site = {
-  name: "Test Directory",
-  blueprintConfig: {
-    id: "project-directory",
-    kind: "project",
-    routeSlug: "projects",
-    itemSlug: "project",
-    labelSingular: "project",
-    labelPlural: "projects",
-  },
-};
-
-describe("getHomePageModel stack counts", () => {
-  it("counts primary AND supporting stacks via the canonical union", () => {
-    const home = getHomePageModel(site as Parameters<typeof getHomePageModel>[0]);
-    const counts = new Map(home.stacks.map((s) => [s.slug, s.count]));
-    expect(counts.get("python")).toBe(3); // a, b, d — d only via supporting
-    expect(counts.get("typescript")).toBe(2);
-    expect(counts.get("go")).toBe(1); // b's supporting stack
-  });
-
-  it("excludes hidden records from homepage counts", () => {
-    const home = getHomePageModel(site as Parameters<typeof getHomePageModel>[0]);
-    expect(home.stacks.find((s) => s.slug === "rust")).toBeUndefined();
-    const categoryTotal = home.categories.reduce((sum, c) => sum + c.count, 0);
-    expect(categoryTotal).toBe(visible.length);
-  });
-
-  it("agrees with the browse facet counts for the same records", async () => {
-    const { buildFacets } = await import("@grove-dev/core");
-    const facets = buildFacets(visible as Parameters<typeof buildFacets>[0]);
-    const facetCounts = new Map(facets.stacks.map((f) => [f.value, f.count]));
-    const home = getHomePageModel(site as Parameters<typeof getHomePageModel>[0]);
-    for (const stack of home.stacks) {
-      expect(facetCounts.get(stack.slug), stack.slug).toBe(stack.count);
-    }
-  });
-});

package/src/server/models.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applySort, filterRecords, filtersFromSearchParams } from "@grove-dev/core";
-
-/**
- * Regression tests for the homepage three-lens sectioning logic.
- *
- * The audit surfaced a bug where the homepage's "Trending now",
- * "Recently added", and "Established" panels all echoed the same
- * record cards because the hot and mature lists were both sliced
- * from the index-order (alphabetical) and ~95% of mature items
- * also carried the hot label.
- *
- * The fix in `getHomePageModel` is twofold:
- *   1. Sort each lens by a meaningful key (stars, then date).
- *   2. Exclude items already surfaced in the previous panels so the
- *      three sections read as distinct perspectives.
- *
- * These tests exercise the underlying primitives the model uses —
- * applying them in the same order the model does — so the recipe
- * stays covered without spinning up the full Astro model layer.
- */
-function record(
-  slug: string,
-  options: { labels?: string[]; stars?: number; reviewedAt?: string } = {},
-) {
-  return {
-    kind: "project" as const,
-    slug,
-    name: slug,
-    description: `${slug} description`,
-    category: "tools",
-    tags: [],
-    stack: "python",
-    stacks: ["python"],
-    platforms: ["linux"],
-    projectType: "real-app",
-    bestFor: [],
-    whyListed: [],
-    caveats: [],
-    links: {},
-    distribution: { channels: [] },
-    source: { type: "manual" as const },
-    visibility: "keep" as const,
-    github: {
-      stars: options.stars ?? 0,
-      forks: 0,
-      openIssues: 0,
-      language: "Python",
-      pushedAt: "2026-01-01T00:00:00Z",
-      archived: false,
-      license: "MIT",
-      fullName: `demo/${slug}`,
-      topics: [],
-    },
-    curation: {
-      reviewed: true,
-      labels: options.labels ?? [],
-      lenses: [],
-      reviewedAt: options.reviewedAt,
-    },
-  };
-}
-
-function sectionLikeModel(records: ReturnType<typeof record>[]) {
-  // Mirrors the filtering, sorting, and exclusion in `getHomePageModel`.
-  const projects = records.filter((r) => r.kind === "project");
-  const hot = applySort(
-    filterRecords(projects, filtersFromSearchParams(new URLSearchParams("label=hot"))),
-    "most-starred",
-  ).slice(0, 6);
-  const hotSlugs = new Set(hot.map((r) => r.slug));
-  const recentlyAdded = applySort(
-    projects.filter((r) => !hotSlugs.has(r.slug)),
-    "recently-added",
-  ).slice(0, 6);
-  const recentSlugs = new Set([...hotSlugs, ...recentlyAdded.map((r) => r.slug)]);
-  const established = applySort(
-    filterRecords(projects, filtersFromSearchParams(new URLSearchParams("label=mature"))).filter(
-      (r) => !recentSlugs.has(r.slug),
-    ),
-    "most-starred",
-  ).slice(0, 6);
-  return {
-    hot: hot.map((r) => r.slug),
-    recentlyAdded: recentlyAdded.map((r) => r.slug),
-    established: established.map((r) => r.slug),
-  };
-}
-
-describe("homepage lens sectioning", () => {
-  it("sorts hot by stars desc and surfaces mature-only items distinct from hot", () => {
-    const records = [
-      record("alpha", { labels: ["hot", "mature"], stars: 1000 }),
-      record("bravo", { labels: ["hot", "mature"], stars: 500 }),
-      record("charlie", { labels: ["mature"], stars: 50 }),
-    ];
-
-    const sections = sectionLikeModel(records);
-    expect(sections.hot).toEqual(["alpha", "bravo"]);
-    // Charlie is the only mature-only item; regardless of which lens
-    // he lands in, he must not also appear in the hot panel.
-    expect(sections.hot).not.toContain("charlie");
-    expect([...sections.recentlyAdded, ...sections.established]).toContain("charlie");
-  });
-
-  it("never repeats a record across the three lens panels", () => {
-    const records = [
-      record("alpha", { labels: ["hot", "mature"], stars: 1000, reviewedAt: "2025-01-01" }),
-      record("bravo", { labels: ["hot", "mature"], stars: 500, reviewedAt: "2025-02-01" }),
-      record("charlie", { labels: ["hot", "mature"], stars: 250, reviewedAt: "2025-03-01" }),
-      record("delta", { labels: ["mature"], stars: 100, reviewedAt: "2024-01-01" }),
-    ];
-
-    const sections = sectionLikeModel(records);
-    const seen = new Set<string>();
-    for (const panel of [sections.hot, sections.recentlyAdded, sections.established]) {
-      for (const slug of panel) {
-        expect(seen.has(slug)).toBe(false);
-        seen.add(slug);
-      }
-    }
-  });
-
-  it("keeps recently-added items out of the hot panel even when they share labels", () => {
-    const records = [
-      record("alpha", { labels: ["hot"], stars: 100, reviewedAt: "2025-06-01" }),
-      record("bravo", { labels: [], stars: 50, reviewedAt: "2026-08-01" }),
-    ];
-
-    const sections = sectionLikeModel(records);
-    expect(sections.hot).toEqual(["alpha"]);
-    expect(sections.recentlyAdded).toEqual(["bravo"]);
-    expect(sections.established).toEqual([]);
-  });
-});

package/src/server/seo.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  absoluteUrl,
-  breadcrumbs,
-  ogPath,
-  recordSeoDescriptor,
-  seoDescription,
-  seoTitle,
-  titleCaseFirst,
-} from "./seo.js";
-
-describe("seoTitle", () => {
-  it("appends the site name with the pipe separator", () => {
-    expect(seoTitle("Collections", "Open Apps")).toBe("Collections | Open Apps");
-  });
-
-  it("skips the suffix when the main part already names the site", () => {
-    expect(seoTitle("Python projects on Open Apps", "Open Apps")).toBe(
-      "Python projects on Open Apps",
-    );
-  });
-
-  it("skips the suffix instead of exceeding the display cap", () => {
-    const long = "A very long record name — with an equally long descriptor attached";
-    expect(seoTitle(long, "Open Apps")).toBe(long);
-  });
-
-  it("falls back to the site name for an empty main part", () => {
-    expect(seoTitle("  ", "Open Apps")).toBe("Open Apps");
-  });
-
-  it("returns the main part unchanged when no site name is given", () => {
-    expect(seoTitle("Collections", "")).toBe("Collections");
-  });
-});
-
-describe("seoDescription", () => {
-  it("prefers the raw text and collapses whitespace", () => {
-    expect(seoDescription("A  spaced\n\ntext.", "fallback")).toBe("A spaced text.");
-  });
-
-  it("uses the fallback when raw is empty", () => {
-    expect(seoDescription(undefined, "The fallback.")).toBe("The fallback.");
-    expect(seoDescription("   ", "The fallback.")).toBe("The fallback.");
-  });
-
-  it("truncates on a word boundary near 160 chars with an ellipsis", () => {
-    const long = "word ".repeat(60).trim();
-    const out = seoDescription(long, "");
-    expect(out.length).toBeLessThanOrEqual(160);
-    expect(out.endsWith("…")).toBe(true);
-    expect(out).not.toMatch(/\swor…$/);
-  });
-});
-
-describe("recordSeoDescriptor", () => {
-  it("uses the summary's first clause when short enough", () => {
-    expect(
-      recordSeoDescriptor({
-        summary: "Self-hosted photo backup. Works offline and syncs later.",
-        singular: "app",
-      }),
-    ).toBe("Self-hosted photo backup");
-  });
-
-  it("falls back to the category phrase when the summary is too long", () => {
-    expect(
-      recordSeoDescriptor({
-        summary:
-          "A very long first clause that keeps going and going far past the cap",
-        categoryLabel: "Photos",
-        singular: "app",
-      }),
-    ).toBe("Open-source Photos app");
-  });
-
-  it("omits the category when it is missing or uncategorized", () => {
-    expect(recordSeoDescriptor({ singular: "project" })).toBe("Open-source project");
-    expect(
-      recordSeoDescriptor({ categoryLabel: "Uncategorized", singular: "project" }),
-    ).toBe("Open-source project");
-  });
-});
-
-describe("titleCaseFirst", () => {
-  it("capitalizes only the first character", () => {
-    expect(titleCaseFirst("projects")).toBe("Projects");
-    expect(titleCaseFirst("")).toBe("");
-  });
-});
-
-describe("ogPath", () => {
-  it("falls back to the static SVG when no generated image exists", () => {
-    // Point at a directory with no public/og at all.
-    expect(ogPath("record", "nothing-here", "/nonexistent-cwd")).toBe("/og-image.svg");
-    expect(ogPath("home", undefined, "/nonexistent-cwd")).toBe("/og-image.svg");
-  });
-});
-
-describe("absoluteUrl", () => {
-  it("joins trailing-slash-safely", () => {
-    expect(absoluteUrl("https://a.com/", "/x/")).toBe("https://a.com/x/");
-    expect(absoluteUrl("https://a.com", "x/")).toBe("https://a.com/x/");
-  });
-});
-
-describe("breadcrumbs", () => {
-  it("builds an absolute BreadcrumbList with trailing slashes", () => {
-    const node = breadcrumbs("https://a.com", [
-      { path: "", name: "Home" },
-      { path: "categories", name: "Categories" },
-      { path: "categories/photos/", name: "Photos" },
-    ]);
-    expect(node["@type"]).toBe("BreadcrumbList");
-    const items = node.itemListElement as Array<{ position: number; name: string; item: string }>;
-    expect(items.map((i) => i.item)).toEqual([
-      "https://a.com/",
-      "https://a.com/categories/",
-      "https://a.com/categories/photos/",
-    ]);
-    expect(items[2]).toMatchObject({ position: 3, name: "Photos" });
-  });
-});

package/src/ui/Badge.astro

@@ -1,38 +0,0 @@
----
-/**
- * Badge — small labeled state indicator.
- *
- * Variant is the MEANING, not the color:
- * - `neutral`  — plain metadata (counts, kinds).
- * - `selected` — "you are here" (neutral inversion, never green).
- * - `success` / `warning` / `danger` / `info` — actual status. These
- *   use the status tokens, so green here means "healthy/succeeded",
- *   not "brand" and not "selected".
- */
-
-export type BadgeVariant = "neutral" | "selected" | "success" | "warning" | "danger" | "info";
-
-interface Props {
-  variant?: BadgeVariant;
-  class?: string;
-  [key: string]: unknown;
-}
-
-const VARIANTS: Record<BadgeVariant, string> = {
-  neutral: "border-border bg-secondary text-secondary-foreground",
-  selected: "border-transparent bg-selected text-selected-foreground",
-  success: "border-transparent bg-success text-success-foreground",
-  warning: "border-transparent bg-warning text-warning-foreground",
-  danger: "border-transparent bg-danger text-danger-foreground",
-  info: "border-transparent bg-info text-info-foreground",
-};
-
-const { variant = "neutral", class: className = "", ...rest } = Astro.props;
----
-
-<span
-  class={`inline-flex min-h-5 items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium leading-none ${VARIANTS[variant]} ${className}`}
-  {...rest}
->
-  <slot />
-</span>

package/src/ui/Button.astro

@@ -1,42 +0,0 @@
----
-/**
- * Button — the shared interactive control.
- *
- * Renders an `<a>` when `href` is given, otherwise a `<button>`.
- * Styling comes exclusively from `buttonClass()` (ui/button.ts) so
- * server components, consumer pages, and the client script share one
- * definition. Pass layout-only extras (widths, one-off spacing)
- * through `class`.
- */
-import { buttonClass, type ButtonSize, type ButtonVariant } from "./button.js";
-
-interface Props {
-  variant?: ButtonVariant;
-  size?: ButtonSize;
-  href?: string;
-  type?: "button" | "submit" | "reset";
-  rel?: string;
-  target?: string;
-  disabled?: boolean;
-  id?: string;
-  class?: string;
-  [key: string]: unknown;
-}
-
-const {
-  variant = "secondary",
-  size = "sm",
-  href,
-  type = "button",
-  class: className = "",
-  ...rest
-} = Astro.props;
-
-const classes = buttonClass(variant, size, className);
----
-
-{href ? (
-  <a href={href} class={classes} {...rest}><slot /></a>
-) : (
-  <button type={type} class={classes} {...rest}><slot /></button>
-)}

package/src/ui/EmptyState.astro

@@ -1,38 +0,0 @@
----
-/**
- * EmptyState — a deliberate "nothing here" block that cannot be
- * mistaken for normal content. Explains WHY the area is empty and
- * offers a recovery action.
- *
- * Marked with `data-grove-empty-state` so quality gates can assert
- * that empty regions render as empty states, not silent gaps.
- */
-import { buttonClass, type ButtonVariant } from "./button.js";
-
-interface Props {
-  title: string;
-  /** Why it's empty / what will make it non-empty. */
-  description?: string;
-  /** Recovery action (rendered as a button-styled link). */
-  action?: { label: string; href: string; variant?: ButtonVariant };
-  class?: string;
-}
-
-const { title, description, action, class: className = "" } = Astro.props;
----
-
-<div
-  data-grove-empty-state
-  class={`flex flex-col items-center gap-2 rounded-[calc(var(--radius)+0.25rem)] border border-dashed border-border bg-surface-sunken px-6 py-10 text-center ${className}`}
->
-  <p class="m-0 text-sm font-medium text-foreground">{title}</p>
-  {description && (
-    <p class="m-0 max-w-[52ch] text-sm leading-relaxed text-muted-foreground">{description}</p>
-  )}
-  <slot />
-  {action && (
-    <a href={action.href} class={buttonClass(action.variant ?? "secondary", "sm", "mt-2")}>
-      {action.label}
-    </a>
-  )}
-</div>