@grove-dev/astro 0.2.10 → 0.2.14

package/templates/default/scripts/sync-contributors.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * sync-contributors — fetch contributors for every record's repoUrl
+ * and write `data/generated/contributors.json` (consumed by the home
+ * page and the /contributors page).
+ *
+ * Generic: walks every record in data/generated/records.index.json,
+ * looks at record.github.fullName or links.github, and calls the
+ * GitHub /repos/{owner}/{repo}/contributors endpoint. Aggregates by
+ * owner (across all of an owner's projects in the directory).
+ *
+ * Anonymous contributors are excluded — the home grid renders <a>
+ * avatars, and a name-less contributor is more confusing than
+ * missing.
+ *
+ * Usage:  node scripts/sync-contributors.mjs
+ * Env:    GH_TOKEN  — required for >60 req/h. Falls back to unauth.
+ *
+ * V1 intentionally small: no retries, no rate-limit backoff beyond
+ * the basic 403-detection. The weekly schedule in
+ * .github/workflows/sync-contributors.yml is loose enough that
+ * re-running the workflow is a fine recovery path.
+ */
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const HERE = new URL(".", import.meta.url).pathname;
+const ROOT = resolve(HERE, "..");
+const GENERATED = resolve(ROOT, "data", "generated");
+const INDEX_PATH = resolve(GENERATED, "records.index.json");
+const OUT_PATH = resolve(GENERATED, "contributors.json");
+
+const GH_TOKEN = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "";
+const HEADERS = {
+  Accept: "application/vnd.github+json",
+  "User-Agent": "grove-sync-contributors",
+  "X-GitHub-Api-Version": "2022-11-28",
+  ...(GH_TOKEN ? { Authorization: `Bearer ${GH_TOKEN}` } : {}),
+};
+
+function ownerRepoFromFullName(fullName) {
+  if (!fullName || !fullName.includes("/")) return null;
+  const [owner, repo] = fullName.split("/", 2);
+  return { owner, repo };
+}
+
+async function ghJson(url) {
+  const res = await fetch(url, { headers: HEADERS });
+  if (res.status === 204) return null;
+  if (res.status === 403) {
+    const remaining = res.headers.get("x-ratelimit-remaining");
+    if (remaining === "0") {
+      throw new Error(`rate-limited (403) on ${url}`);
+    }
+    return null;
+  }
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`HTTP ${res.status} on ${url}`);
+  return res.json();
+}
+
+async function fetchContributorsForRepo(owner, repo) {
+  // GitHub caps /contributors at 500; for our purposes (fanning into
+  // a home grid) we only need the first page. Anonymous entries
+  // (no `login`) are dropped at parse time.
+  const url = `https://api.github.com/repos/${owner}/${repo}/contributors?per_page=100&anon=false`;
+  const data = await ghJson(url);
+  if (!Array.isArray(data)) return [];
+  return data
+    .filter((c) => c && c.login)
+    .map((c) => ({
+      username: c.login,
+      avatarUrl: c.avatar_url,
+      profileUrl: c.html_url,
+      contributions: c.contributions ?? 0,
+    }));
+}
+
+async function main() {
+  let index;
+  try {
+    index = JSON.parse(await readFile(INDEX_PATH, "utf8"));
+  } catch (err) {
+    console.error(`Could not read ${INDEX_PATH}: ${err.message}`);
+    console.error("Run `pnpm run build:data` first.");
+    process.exit(1);
+  }
+
+  const records = Array.isArray(index.records) ? index.records : [];
+  // Group by owner — a single person with three projects in the
+  // directory shows up once with the summed contribution count.
+  const byOwner = new Map();
+  const seenRepos = new Set();
+
+  for (const r of records) {
+    const gh = r.github || {};
+    const ref = ownerRepoFromFullName(gh.fullName) || (() => {
+      const url = r.repoUrl || (r.links && r.links.github) || "";
+      const m = /github\.com\/([^/]+)\/([^/?#]+)/.exec(url);
+      return m ? { owner: m[1], repo: m[2].replace(/\.git$/, "") } : null;
+    })();
+    if (!ref) continue;
+    if (seenRepos.has(`${ref.owner}/${ref.repo}`)) continue;
+    seenRepos.add(`${ref.owner}/${ref.repo}`);
+
+    try {
+      const list = await fetchContributorsForRepo(ref.owner, ref.repo);
+      for (const c of list) {
+        const existing = byOwner.get(c.username);
+        if (existing) {
+          existing.contributions = (existing.contributions ?? 0) + c.contributions;
+        } else {
+          byOwner.set(c.username, c);
+        }
+      }
+      console.log(`  ${ref.owner}/${ref.repo}: ${list.length} contributors`);
+    } catch (err) {
+      console.warn(`  ${ref.owner}/${ref.repo}: ${err.message}`);
+    }
+  }
+
+  const contributors = [...byOwner.values()].sort(
+    (a, b) => (b.contributions ?? 0) - (a.contributions ?? 0),
+  );
+
+  await mkdir(dirname(OUT_PATH), { recursive: true });
+  await writeFile(
+    OUT_PATH,
+    JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        contributors,
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  console.log(`\nWrote ${contributors.length} contributors → ${OUT_PATH}`);
+}
+
+main().catch((err) => {
+  console.error(err.stack || err.message);
+  process.exit(1);
+});

package/templates/default/scripts/sync-github-metadata.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+
+/**
+ * sync-github-metadata.mjs — full metadata sync from GitHub's
+ * REST API. Wrapper around `@grove-dev/cli sync github`.
+ *
+ * Refreshes stargazers_count, forks_count, license, default branch,
+ * pushed_at, language, topics, and the contributor list for every
+ * record whose `repoUrl` is a GitHub repository.
+ *
+ * Writes back into the corresponding `data/records/<slug>.yml` (the
+ * CLI is conservative — only fills in fields that are currently
+ * empty).
+ */
+import { spawnSync } from "node:child_process";
+
+const result = spawnSync("grove", ["sync", "github"], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+if (result.error) {
+  console.error("Failed to spawn `grove sync github`:", result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 0);

package/templates/default/scripts/validate-records.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+
+/**
+ * validate-records.mjs — Zod-schema validation for every record yml.
+ *
+ * Thin wrapper around `@grove-dev/cli`'s `validate` command so the
+ * `pnpm run validate:data` script works without V0 command names.
+ *
+ * For schema authoring see `packages/core/src/schema.ts`. The CLI
+ * handles every blueprint (project-directory, resource-hub,
+ * ecosystem-map) and every record kind (project, resource, entity).
+ */
+import { spawnSync } from "node:child_process";
+
+const result = spawnSync("grove", ["validate"], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+if (result.error) {
+  console.error("Failed to spawn `grove validate`:", result.error.message);
+  console.error("Make sure `@grove-dev/cli` is installed and on PATH.");
+  process.exit(1);
+}
+
+process.exit(result.status ?? 0);

package/templates/default/src/data/records.ts

@@ -1,28 +1,33 @@
 /**
- * Source of truth: `data/generated/records.{full,index,json}`,
- * produced at build time by `grove generate` from
- * `data/records/*.yml`.
+ *  Source of truth: `data/generated/records.{full,index,json}` and
+ *  `data/generated/site-config.json`, produced at build time by
+ *  `grove generate` from `data/records/*.yml` and `grove.config.ts`.
  *
- * Three flavors are written by the generator:
+ *  Three flavors of records are written by the generator:
  *
- *   - `records.full.json`   — every record, all visibility. Carries
- *     every normalized field (including `content`, `bestFor`,
- *     `whyListed`, `caveats`, full `github.repository`, ...).
- *     Use this for the detail page.
- *   - `records.index.json`  — slim projection, visible-only. Use
- *     this for the list page and any home-page sectioning. Shape
- *     is the `IndexRecord` discriminated union from `@grove-dev/core`.
- *   - `records.json`        — alias of `records.full.json`.
+ *    - `records.full.json`   — every record, all visibility. Carries
+ *      every normalized field (including `content`, `bestFor`,
+ *      `whyListed`, `caveats`, full `github.repository`, ...).
+ *      Use this for the detail page.
+ *    - `records.index.json`  — slim projection, visible-only. Use
+ *      this for the list page and any home-page sectioning. Shape
+ *      is the `IndexRecord` discriminated union from `@grove-dev/core`.
+ *    - `records.json`        — alias of `records.full.json`.
  *
- * The YML files are the human-edited source; this module is a
- * typed re-export so pages can import the records without parsing
- * JSON inline. Pages cast to the kind they expect based on the
- * blueprint in `grove.config.ts`.
+ *  The YML files are the human-edited source; this module is a
+ *  typed re-export so pages can import the records without parsing
+ *  JSON inline.
  *
- * When the JSON files are missing (e.g. before `grove generate`
- * runs, or in a fresh scaffold with no records) this module falls
- * back to empty arrays so the Astro build still succeeds — every
- * page must render a graceful "no records yet" state.
+ *  Blueprint-aware helpers (`indexSlug`, `itemLabel`, `itemsByKind`,
+ *  `items` default export) read from `data/generated/site-config.json`'s
+ *  `blueprintConfig` block, so the same module works for all three
+ *  blueprints — `project-directory` (default), `resource-hub`, and
+ *  `ecosystem-map` — without per-blueprint forks.
+ *
+ *  When the JSON files are missing (e.g. before `grove generate`
+ *  runs, or in a fresh scaffold with no records) this module falls
+ *  back to empty arrays so the Astro build still succeeds — every
+ *  page must render a graceful "no records yet" state.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -55,6 +60,22 @@ interface IndexPayload {
   records?: IndexRecord[];
 }
 
+interface SiteConfigPayload {
+  blueprint?: string;
+  blueprintConfig?: {
+    id?: string;
+    kind?: "project" | "resource" | "entity";
+    routeSlug?: string;
+    itemSlug?: string;
+    /** V1 canonical field name for the record detail slug
+     * (replaces the V0 `itemSlug` field). */
+    recordSlug?: string;
+    labelSingular?: string;
+    labelPlural?: string;
+  };
+  name?: string;
+}
+
 function loadGenerated<T>(filename: string, parser: (raw: string) => T): T {
   // The Astro build resolves JSON imports from `src/data/*.ts`, but
   // we want to be defensive about the order of operations: a fresh
@@ -103,17 +124,29 @@ const indexRecordsRaw: IndexRecord[] = loadGenerated(
   },
 );
 
+const siteConfigRaw: SiteConfigPayload = loadGenerated(
+  "site-config.json",
+  (raw) => {
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw) as SiteConfigPayload;
+    } catch {
+      return {};
+    }
+  },
+);
+
 /**
- * Full records (all visibility). Use this for the detail page,
- * where you need `content`, `bestFor`, `whyListed`, `caveats`,
- * the full `github.repository` block, etc.
+ *  Full records (all visibility). Use this for the detail page,
+ *  where you need `content`, `bestFor`, `whyListed`, `caveats`,
+ *  the full `github.repository` block, etc.
  */
 export const fullRecords: Resource[] = fullRecordsRaw;
 
 /**
- * Index-payload records (visible only). Use this for the list
- * page and any home-page sectioning, where you only need the
- * slim search-index fields.
+ *  Index-payload records (visible only). Use this for the list
+ *  page and any home-page sectioning, where you only need the
+ *  slim search-index fields.
  */
 export const records: IndexRecord[] =
   indexRecordsRaw.length > 0 ? indexRecordsRaw : [];
@@ -140,8 +173,8 @@ export function recordBySlug(slug: string): Resource | undefined {
 }
 
 /**
- * Generic slug lookup. The spec name is `findRecord`; this is an
- * alias of `recordBySlug` so consumers can use either spelling.
+ *  Generic slug lookup. The spec name is `findRecord`; this is an
+ *  alias of `recordBySlug` so consumers can use either spelling.
  */
 export function findRecord(slug: string): Resource | undefined {
   return bySlug.get(slug);
@@ -162,32 +195,86 @@ export function entityBySlug(slug: string): EntityRecord | undefined {
   return r && r.kind === "entity" ? r : undefined;
 }
 
+// ──────────────────────────────────────────────────────────────────────
+// Blueprint-aware generic helpers
+// ──────────────────────────────────────────────────────────────────────
+//
+// Every page (home, list, detail, submit) needs to know the
+// route slug, the kind filter, and the human label. Rather than
+// hardcode "project" / "projects" / "kind: project" at every
+// call-site, we derive them once from `site-config.json`'s
+// `blueprintConfig` block (populated by `grove generate`).
+//
+// `indexSlug()` and `itemLabel()` retain their old signatures
+// (zero-arg) so existing pages keep working — they now read from
+// the JSON instead of a switch statement.
+
+const blueprintConfig = siteConfigRaw.blueprintConfig ?? {};
+const blueprintKind = (blueprintConfig.kind ?? "project") as
+  | "project"
+  | "resource"
+  | "entity";
+const blueprintId = (blueprintConfig.id ?? "project-directory") as
+  | "project-directory"
+  | "resource-hub"
+  | "ecosystem-map";
+
 /**
- * Page slug for the directory index page, derived from the
- * blueprint in `grove.config.ts` (mirrors the helper that used
- * to live in `data/site-config.ts`).
+ * URL slug for the directory index page (e.g. `/projects/`,
+ * `/resources/`, `/entities/`). Override in `grove.config.ts`
+ * via `routes.directory` — reflected through to here at generate
+ * time.
  */
-export function indexSlug(blueprint: string | undefined): string {
-  switch (blueprint) {
-    case "resource-hub":
-      return "resources";
-    case "ecosystem-map":
-      return "entities";
-    case "project-directory":
-    default:
-      return "projects";
-  }
+export function indexSlug(): string {
+  return blueprintConfig.routeSlug ?? "projects";
 }
 
-/** Human label for items in the UI. */
-export function itemLabel(blueprint: string | undefined): string {
-  switch (blueprint) {
-    case "resource-hub":
-      return "resource";
-    case "ecosystem-map":
-      return "entity";
-    case "project-directory":
+/** URL slug for a single record detail page (the dynamic
+ * `[recordSlug]` segment). Default "project" for backwards-compat
+ * with V0-published configs that exposed the field as `itemSlug`. */
+export function recordSlugConfig(): string {
+  return blueprintConfig.recordSlug ?? blueprintConfig.itemSlug ?? "project";
+}
+
+/** Singular human label, e.g. "project", "resource", "entity". */
+export function itemLabel(): string {
+  return blueprintConfig.labelSingular ?? "project";
+}
+
+/** Plural human label, e.g. "projects", "resources", "entities". */
+export function itemLabelPlural(): string {
+  return blueprintConfig.labelPlural ?? "projects";
+}
+
+/** Active blueprint id. */
+export function blueprintIdFn(): string {
+  return blueprintId;
+}
+
+/** Active record kind discriminator. */
+export function activeKind(): "project" | "resource" | "entity" {
+  return blueprintKind;
+}
+
+/**
+ * Generic items alias. Defaults to the kind this blueprint
+ * produces (project/resource/entity). Use this for all
+ * "list"-flavoured pages so a single template works for every
+ * blueprint.
+ */
+export const items: IndexRecord[] = (() => {
+  switch (blueprintKind) {
+    case "resource":
+      return resources;
+    case "entity":
+      return entities;
+    case "project":
     default:
-      return "project";
+      return projects;
   }
-}
+})();
+
+/** Generic full-record alias. */
+export const fullItems: Resource[] = (() => {
+  return fullRecords.filter((r) => r.kind === blueprintKind);
+})();

package/templates/default/src/pages/404.astro

@@ -0,0 +1,64 @@
+---
+/**
+ * 404 — generic fallback page.
+ *
+ * Renders the normal shell (header / footer / theme toggle) with a
+ * short message and a search form pointing at the list page. Stays
+ * on-brand regardless of blueprint.
+ */
+import siteConfig from "../../data/generated/site-config.json";
+import { indexSlug } from "../data/records";
+import BaseLayout from "@grove-dev/astro/layouts/BaseLayout.astro";
+
+const slug = indexSlug();
+const title = `Not found — ${siteConfig.name}`;
+const description = `That page doesn't exist on ${siteConfig.name}.`;
+---
+
+<BaseLayout
+  title={title}
+  description={description}
+  site={siteConfig}
+  noindex
+>
+  <section class="grove-section">
+    <div class="grove-container mx-auto px-5 py-20 sm:px-7 sm:py-28">
+      <span class="text-2xs font-medium uppercase tracking-wider text-ink-500 dark:text-ink-400">
+        404
+      </span>
+      <h1 class="m-0 mt-2 text-[2.25rem] sm:text-[3rem] font-semibold leading-[1.05] tracking-tight text-ink-900 dark:text-ink-100">
+        Page not found
+      </h1>
+      <p class="m-0 mt-4 max-w-xl text-lg leading-relaxed text-ink-700 dark:text-ink-200">
+        The page you're looking for doesn't exist on {siteConfig.name}.
+        It may have been moved, renamed, or never existed.
+      </p>
+
+      <form
+        class="mt-8 flex max-w-xl flex-col gap-2 sm:flex-row sm:items-center"
+        role="search"
+        action={`/${slug}`}
+        method="get"
+      >
+        <label class="relative flex-1">
+          <span class="sr-only">Search</span>
+          <input
+            type="search"
+            name="q"
+            placeholder={`Search ${slug}...`}
+            autocomplete="off"
+            class="w-full rounded-md border border-ink-200 bg-white py-2.5 px-3 text-sm placeholder:text-ink-400 focus:border-ink-900 focus:outline-none focus:ring-2 focus:ring-ink-900/10 dark:border-ink-800 dark:bg-ink-950 dark:text-ink-100"
+          />
+        </label>
+        <button type="submit" class="grove-btn grove-btn-primary">
+          Search
+        </button>
+      </form>
+
+      <div class="mt-6 flex flex-wrap gap-3">
+        <a href="/" class="grove-btn grove-btn-primary">Back to home</a>
+        <a href={`/${slug}`} class="grove-btn grove-btn-outline">Browse {slug}</a>
+      </div>
+    </div>
+  </section>
+</BaseLayout>