feat: add radicle + forgejo, fix tangled meta, and ensure meta is fetched on ssr

Author: danielroe

app/composables/useNpmRegistry.ts

@@ -162,40 +162,36 @@ export function usePackage(
   name: MaybeRefOrGetter<string>,
   requestedVersion?: MaybeRefOrGetter<string | null>,
 ) {
-  const asyncData = useLazyAsyncData(
+  return useLazyAsyncData(
     () => `package:${toValue(name)}:${toValue(requestedVersion) ?? ''}`,
-    () =>
-      fetchNpmPackage(toValue(name)).then(r => transformPackument(r, toValue(requestedVersion))),
+    async () => {
+      const r = await fetchNpmPackage(toValue(name))
+      const reqVer = toValue(requestedVersion)
+      const pkg = transformPackument(r, reqVer)
+      const resolvedVersion = getResolvedVersion(pkg, reqVer)
+      return { ...pkg, resolvedVersion }
+    },
   )
+}
 
-  // Resolve requestedVersion to an exact version
-  // Handles: exact versions, dist-tags (latest, next), and semver ranges (^4.2, >=1.0.0)
-  const resolvedVersion = computed(() => {
-    const pkg = asyncData.data.value
-    const reqVer = toValue(requestedVersion)
-    if (!pkg || !reqVer) return null
-
-    // 1. Check if it's already an exact version in pkg.versions
-    if (isExactVersion(reqVer) && pkg.versions[reqVer]) {
-      return reqVer
-    }
-
-    // 2. Check if it's a dist-tag (latest, next, beta, etc.)
-    const tagVersion = pkg['dist-tags']?.[reqVer]
-    if (tagVersion) {
-      return tagVersion
-    }
+function getResolvedVersion(pkg: SlimPackument, reqVer?: string | null): string | null {
+  if (!pkg || !reqVer) return null
 
-    // 3. Try to resolve as a semver range
-    const versions = Object.keys(pkg.versions)
-    const resolved = maxSatisfying(versions, reqVer)
-    return resolved
-  })
+  // 1. Check if it's already an exact version in pkg.versions
+  if (isExactVersion(reqVer) && pkg.versions[reqVer]) {
+    return reqVer
+  }
 
-  return {
-    ...asyncData,
-    resolvedVersion,
+  // 2. Check if it's a dist-tag (latest, next, beta, etc.)
+  const tagVersion = pkg['dist-tags']?.[reqVer]
+  if (tagVersion) {
+    return tagVersion
   }
+
+  // 3. Try to resolve as a semver range
+  const versions = Object.keys(pkg.versions)
+  const resolved = maxSatisfying(versions, reqVer)
+  return resolved
 }
 
 export function usePackageDownloads(

app/composables/useRepoMeta.ts

@@ -69,6 +69,19 @@ type GiteeRepoResponse = {
   watchers_count?: number
 }
 
+/** Radicle API response for project details */
+type RadicleProjectResponse = {
+  id: string
+  name: string
+  description?: string
+  defaultBranch?: string
+  head?: string
+  seeding?: number
+  delegates?: Array<{ id: string; alias?: string }>
+  patches?: { open: number; draft: number; archived: number; merged: number }
+  issues?: { open: number; closed: number }
+}
+
 type ProviderAdapter = {
   id: ProviderId
   parse(url: URL): RepoRef | null
@@ -491,22 +504,146 @@ const tangledAdapter: ProviderAdapter = {
   },
 
   links(ref) {
-    const base = `https://tangled.sh/${ref.owner}/${ref.repo}`
+    const base = `https://tangled.org/${ref.owner}/${ref.repo}`
     return {
       repo: base,
       stars: base, // Tangled shows stars on the repo page
       forks: `${base}/fork`,
     }
   },
 
-  async fetchMeta(_ref, links) {
-    // Tangled doesn't have a public API for repo stats yet
-    // Just return basic info without fetching
+  async fetchMeta(ref, links) {
+    // Tangled doesn't have a public JSON API, but we can scrape the star count
+    // from the HTML page (it's in the hx-post URL as countHint=N)
+    try {
+      const html = await $fetch<string>(`https://tangled.org/${ref.owner}/${ref.repo}`, {
+        headers: { 'User-Agent': 'npmx', 'Accept': 'text/html' },
+      })
+      // Extract star count from: hx-post="/star?subject=...&countHint=23"
+      const starMatch = html.match(/countHint=(\d+)/)
+      const stars = starMatch?.[1] ? parseInt(starMatch[1], 10) : 0
+
+      return {
+        provider: 'tangled',
+        url: links.repo,
+        stars,
+        forks: 0, // Tangled doesn't expose fork count
+        links,
+      }
+    } catch {
+      return {
+        provider: 'tangled',
+        url: links.repo,
+        stars: 0,
+        forks: 0,
+        links,
+      }
+    }
+  },
+}
+
+const radicleAdapter: ProviderAdapter = {
+  id: 'radicle',
+
+  parse(url) {
+    const host = url.hostname.toLowerCase()
+    if (host !== 'radicle.at' && host !== 'app.radicle.at' && host !== 'seed.radicle.at') {
+      return null
+    }
+
+    // Radicle URLs: app.radicle.at/nodes/seed.radicle.at/rad:z3nP4yT1PE3m1PxLEzr173sZtJVnT
+    const path = url.pathname
+    const radMatch = path.match(/rad:[a-zA-Z0-9]+/)
+    if (!radMatch?.[0]) return null
+
+    // Use empty owner, store full rad: ID as repo
+    return { provider: 'radicle', owner: '', repo: radMatch[0], host }
+  },
+
+  links(ref) {
+    const base = `https://app.radicle.at/nodes/seed.radicle.at/${ref.repo}`
     return {
-      provider: 'tangled',
+      repo: base,
+      stars: base, // Radicle doesn't have stars, shows seeding count
+      forks: base,
+    }
+  },
+
+  async fetchMeta(ref, links) {
+    const res = await $fetch<RadicleProjectResponse>(
+      `https://seed.radicle.at/api/v1/projects/${ref.repo}`,
+      { headers: { 'User-Agent': 'npmx' } },
+    ).catch(() => null)
+
+    if (!res) return null
+
+    return {
+      provider: 'radicle',
       url: links.repo,
-      stars: 0,
-      forks: 0,
+      // Use seeding count as a proxy for "stars" (number of nodes hosting this repo)
+      stars: res.seeding ?? 0,
+      forks: 0, // Radicle doesn't have forks in the traditional sense
+      description: res.description ?? null,
+      defaultBranch: res.defaultBranch,
+      links,
+    }
+  },
+}
+
+const forgejoAdapter: ProviderAdapter = {
+  id: 'forgejo',
+
+  parse(url) {
+    const host = url.hostname.toLowerCase()
+
+    // Match explicit Forgejo instances
+    const forgejoPatterns = [/^forgejo\./i, /\.forgejo\./i]
+    const knownInstances = ['next.forgejo.org', 'try.next.forgejo.org']
+
+    const isMatch = knownInstances.some(h => host === h) || forgejoPatterns.some(p => p.test(host))
+    if (!isMatch) return null
+
+    const parts = url.pathname.split('/').filter(Boolean)
+    if (parts.length < 2) return null
+
+    const owner = decodeURIComponent(parts[0] ?? '').trim()
+    const repo = decodeURIComponent(parts[1] ?? '')
+      .trim()
+      .replace(/\.git$/i, '')
+
+    if (!owner || !repo) return null
+
+    return { provider: 'forgejo', owner, repo, host }
+  },
+
+  links(ref) {
+    const base = `https://${ref.host}/${ref.owner}/${ref.repo}`
+    return {
+      repo: base,
+      stars: base,
+      forks: `${base}/forks`,
+      watchers: base,
+    }
+  },
+
+  async fetchMeta(ref, links) {
+    if (!ref.host) return null
+
+    const res = await $fetch<GiteaRepoResponse>(
+      `https://${ref.host}/api/v1/repos/${ref.owner}/${ref.repo}`,
+      { headers: { 'User-Agent': 'npmx' } },
+    ).catch(() => null)
+
+    if (!res) return null
+
+    return {
+      provider: 'forgejo',
+      url: links.repo,
+      stars: res.stars_count ?? 0,
+      forks: res.forks_count ?? 0,
+      watchers: res.watchers_count ?? 0,
+      description: res.description ?? null,
+      defaultBranch: res.default_branch,
       links,
     }
   },
@@ -521,6 +658,8 @@ const providers: readonly ProviderAdapter[] = [
   giteeAdapter,
   sourcehutAdapter,
   tangledAdapter,
+  radicleAdapter,
+  forgejoAdapter,
   giteaAdapter, // Generic Gitea adapter last as fallback for self-hosted instances
 ] as const
 

app/pages/[...package].vue

@@ -67,8 +67,6 @@ const orgName = computed(() => {
   return match ? match[1] : null
 })
 
-const { data: pkg, status, error, resolvedVersion } = usePackage(packageName, requestedVersion)
-
 const { data: downloads } = usePackageDownloads(packageName, 'last-week')
 const { data: weeklyDownloads } = usePackageWeeklyDownloadEvolution(packageName, { weeks: 52 })
 
@@ -126,6 +124,9 @@ const sizeTooltip = computed(() => {
   return chunks.filter(Boolean).join('\n')
 })
 
+const { data: pkg, status, error } = await usePackage(packageName, requestedVersion)
+const resolvedVersion = computed(() => pkg.value?.resolvedVersion ?? null)
+
 // Get the version to display (resolved version or latest)
 const displayVersion = computed(() => {
   if (!pkg.value) return null
@@ -194,9 +195,11 @@ const PROVIDER_ICONS: Record<string, string> = {
   bitbucket: 'i-simple-icons-bitbucket',
   codeberg: 'i-simple-icons-codeberg',
   gitea: 'i-simple-icons-gitea',
+  forgejo: 'i-simple-icons-forgejo',
   gitee: 'i-simple-icons-gitee',
   sourcehut: 'i-simple-icons-sourcehut',
   tangled: 'i-custom-tangled',
+  radicle: 'i-carbon-network-3', // Radicle is a P2P network, using network icon
 }
 
 const repoProviderIcon = computed(() => {