bitzzdev

1// Unified repository data layer for bitz.is-a.dev/repos.
2// Prefers GitHub (bitzzdev) and falls back to GitLab (bitzzdev) when the
3// GitHub account is unavailable or returns no public repositories.
4 
5export const GITHUB_USER = "bitzzdev";
6export const GITLAB_USER = "bitzzdev";
7export const GITLAB_NAMESPACE = "bitzzdev";
8 
9export type GitSource = "github" | "gitlab";
10 
11export interface RepoSummary {
12  id: string;
13  name: string;
14  description: string;
15  webUrl: string;
16  cloneHttp: string;
17  cloneSsh: string;
18  defaultBranch: string;
19  topics: string[];
20  language: string | null;
21  stars: number;
22  forks: number;
23  fork: boolean;
24  archived: boolean;
25  lastActivity: string;
26  source: GitSource;
27}
28 
29export interface ReposListResult {
30  repos: RepoSummary[];
31  source: GitSource;
32  githubOk: boolean;
33  /** true when both APIs were unavailable and the cached snapshot is served */
34  degraded: boolean;
35}
36 
37export interface TreeEntry {
38  name: string;
39  path: string;
40  type: "dir" | "file";
41  size: number | null;
42}
43 
44export interface FileContent {
45  name: string;
46  path: string;
47  size: number;
48  text: string | null;
49  isBinary: boolean;
50  tooLarge: boolean;
51}
52 
53export interface CommitEntry {
54  shortId: string;
55  title: string;
56  authorName: string;
57  authoredAt: string;
58  url: string;
59}
60 
61export interface BranchEntry {
62  name: string;
63  isDefault: boolean;
64}
65 
66export interface TagEntry {
67  name: string;
68}
69 
70export interface LanguageShare {
71  name: string;
72  pct: number;
73}
74 
75import { REPO_FALLBACK_REPOS } from "./repos-fallback";
76 
77const REVALIDATE = 300;
78const MAX_FILE_BYTES = 512 * 1024;
79const MAX_LINES = 5000;
80 
81function fetchOpts(): RequestInit & { next: { revalidate: number } } {
82  return {
83    headers: {
84      "User-Agent": "bitz.is-a.dev",
85      Accept: "application/json",
86    },
87    next: { revalidate: REVALIDATE },
88  };
89}
90 
91function sleep(ms: number): Promise<void> {
92  return new Promise((resolve) => setTimeout(resolve, ms));
93}
94 
95async function fetchJson(
96  url: string,
97  attempt = 0
98): Promise<{ ok: boolean; status: number; body: unknown }> {
99  try {
100    const res = await fetch(url, fetchOpts());
101    let body: unknown = null;
102    try {
103      body = await res.json();
104    } catch {
105      body = null;
106    }
107    if ((res.status === 429 || res.status >= 500) && attempt < 1) {
108      await sleep(1200);
109      return fetchJson(url, attempt + 1);
110    }
111    return { ok: res.ok, status: res.status, body };
112  } catch {
113    if (attempt < 1) {
114      await sleep(1200);
115      return fetchJson(url, attempt + 1);
116    }
117    return { ok: false, status: 0, body: null };
118  }
119}
120 
121export function safePath(p: string): string {
122  const cleaned = p.replace(/^\/+|\/+$/g, "");
123  if (cleaned.split("/").some((seg) => seg === ".." || seg === "." || seg === "")) return "";
124  return cleaned;
125}
126 
127export function safeRef(ref: string, fallback: string): string {
128  if (!ref) return fallback;
129  return /^[A-Za-z0-9._\-/]{1,200}$/.test(ref) && !ref.includes("..") ? ref : fallback;
130}
131 
132export function relTime(iso: string, now: number): string {
133  const t = Date.parse(iso);
134  if (Number.isNaN(t)) return "unknown";
135  const diff = Math.max(0, now - t);
136  const mins = Math.floor(diff / 60000);
137  if (mins < 1) return "just now";
138  if (mins < 60) return `${mins}m ago`;
139  const hours = Math.floor(mins / 60);
140  if (hours < 24) return `${hours}h ago`;
141  const days = Math.floor(hours / 24);
142  if (days < 30) return `${days}d ago`;
143  const months = Math.floor(days / 30);
144  if (months < 12) return `${months}mo ago`;
145  const years = Math.floor(months / 12);
146  return `${years}y ago`;
147}
148 
149export function rawBase(source: GitSource, name: string, ref: string): string {
150  return source === "github"
151    ? `https://raw.githubusercontent.com/${GITHUB_USER}/${name}/${ref}/`
152    : `https://gitlab.com/${GITLAB_NAMESPACE}/${name}/-/raw/${ref}/`;
153}
154 
155export function blobBase(source: GitSource, name: string, ref: string): string {
156  return source === "github"
157    ? `https://github.com/${GITHUB_USER}/${name}/blob/${ref}/`
158    : `https://gitlab.com/${GITLAB_NAMESPACE}/${name}/-/blob/${ref}/`;
159}
160 
161export function archiveUrl(source: GitSource, name: string, ref: string): string {
162  return source === "github"
163    ? `https://codeload.github.com/${GITHUB_USER}/${name}/tar.gz/${ref}`
164    : `https://gitlab.com/${GITLAB_NAMESPACE}/${name}/-/archive/${ref}/${name}-${ref}.tar.gz`;
165}
166 
167/* GitHub                                                              */
168 
169interface GithubApiRepo {
170  id: number;
171  name: string;
172  description: string | null;
173  html_url: string;
174  language: string | null;
175  stargazers_count: number;
176  forks_count: number;
177  fork: boolean;
178  archived: boolean;
179  pushed_at: string;
180  default_branch: string;
181  topics?: string[];
182}
183 
184function fromGithub(r: GithubApiRepo): RepoSummary {
185  return {
186    id: `github:${r.id}`,
187    name: r.name,
188    description: r.description ?? "",
189    webUrl: r.html_url,
190    cloneHttp: `https://github.com/${GITHUB_USER}/${r.name}.git`,
191    cloneSsh: `git@github.com:${GITHUB_USER}/${r.name}.git`,
192    defaultBranch: r.default_branch || "main",
193    topics: r.topics ?? [],
194    language: r.language,
195    stars: r.stargazers_count ?? 0,
196    forks: r.forks_count ?? 0,
197    fork: !!r.fork,
198    archived: !!r.archived,
199    lastActivity: r.pushed_at,
200    source: "github",
201  };
202}
203 
204export async function listGithub(): Promise<RepoSummary[] | null> {
205  const { ok, body } = await fetchJson(
206    `https://api.github.com/users/${GITHUB_USER}/repos?per_page=100&sort=updated`
207  );
208  if (!ok || !Array.isArray(body) || body.length === 0) return null;
209  return (body as GithubApiRepo[]).map(fromGithub);
210}
211 
212/* GitLab                                                              */
213 
214interface GitlabApiProject {
215  id: number;
216  path: string;
217  name: string;
218  description: string | null;
219  web_url: string;
220  ssh_url_to_repo: string;
221  http_url_to_repo: string;
222  default_branch: string | null;
223  topics?: string[];
224  tag_list?: string[];
225  star_count: number;
226  forks_count: number;
227  forked_from_project?: unknown;
228  archived?: boolean;
229  last_activity_at: string;
230}
231 
232function fromGitlab(p: GitlabApiProject): RepoSummary {
233  return {
234    id: `gitlab:${p.id}`,
235    name: p.path,
236    description: p.description ?? "",
237    webUrl: p.web_url,
238    cloneHttp: p.http_url_to_repo,
239    cloneSsh: p.ssh_url_to_repo,
240    defaultBranch: p.default_branch || "main",
241    topics: p.topics ?? p.tag_list ?? [],
242    language: null,
243    stars: p.star_count ?? 0,
244    forks: p.forks_count ?? 0,
245    fork: !!p.forked_from_project,
246    archived: !!p.archived,
247    lastActivity: p.last_activity_at,
248    source: "gitlab",
249  };
250}
251 
252function gitlabProjectId(name: string): string {
253  return encodeURIComponent(`${GITLAB_NAMESPACE}/${name}`);
254}
255 
256export async function listGitlab(): Promise<RepoSummary[] | null> {
257  const { ok, body } = await fetchJson(
258    `https://gitlab.com/api/v4/users/${GITLAB_USER}/projects?per_page=100&order_by=updated_at`
259  );
260  if (!ok || !Array.isArray(body)) return null;
261  return (body as GitlabApiProject[]).map(fromGitlab);
262}
263 
264/* Fallback orchestration                                              */
265 
266export async function getAllRepos(): Promise<ReposListResult> {
267  const gh = await listGithub();
268  if (gh) {
269    gh.sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity));
270    return { repos: gh, source: "github", githubOk: true, degraded: false };
271  }
272  const gl = await listGitlab();
273  if (gl && gl.length > 0) {
274    gl.sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity));
275    return { repos: gl, source: "gitlab", githubOk: false, degraded: false };
276  }
277  const snapshot = [...REPO_FALLBACK_REPOS].sort(
278    (a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)
279  );
280  return { repos: snapshot, source: "gitlab", githubOk: false, degraded: true };
281}
282 
283export async function getRepo(name: string): Promise<RepoSummary | null> {
284  const { repos } = await getAllRepos();
285  const needle = name.toLowerCase();
286  return (
287    repos.find(
288      (r) => r.name.toLowerCase() === needle || r.webUrl.split("/").pop()?.toLowerCase() === needle
289    ) ?? null
290  );
291}
292 
293/* Languages                                                           */
294 
295export async function getLanguages(source: GitSource, name: string): Promise<LanguageShare[]> {
296  if (source === "github") {
297    const { ok, body } = await fetchJson(`https://api.github.com/repos/${GITHUB_USER}/${name}/languages`);
298    if (!ok || !body || typeof body !== "object") return [];
299    const entries = Object.entries(body as Record<string, number>);
300    const total = entries.reduce((sum, [, v]) => sum + v, 0);
301    if (total <= 0) return [];
302    return entries
303      .map(([lang, bytes]) => ({ name: lang, pct: Math.round((bytes / total) * 1000) / 10 }))
304      .sort((a, b) => b.pct - a.pct);
305  }
306  const { ok, body } = await fetchJson(`https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/languages`);
307  if (!ok || !body || typeof body !== "object") return [];
308  return Object.entries(body as Record<string, number>)
309    .map(([lang, pct]) => ({ name: lang, pct: Math.round(pct * 10) / 10 }))
310    .sort((a, b) => b.pct - a.pct);
311}
312 
313/* README                                                              */
314 
315const README_CANDIDATES = [
316  "README.md", "readme.md", "Readme.md",
317  "README.markdown", "README.rst", "README.txt", "README",
318];
319 
320export interface ReadmeResult {
321  name: string;
322  content: string;
323}
324 
325export async function getReadme(source: GitSource, name: string, ref: string): Promise<ReadmeResult | null> {
326  for (const candidate of README_CANDIDATES) {
327    const url =
328      source === "github"
329        ? `https://raw.githubusercontent.com/${GITHUB_USER}/${name}/${ref}/${candidate}`
330        : `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/files/${encodeURIComponent(candidate)}/raw?ref=${encodeURIComponent(ref)}`;
331    try {
332      const res = await fetch(url, fetchOpts());
333      if (!res.ok) continue;
334      const content = await res.text();
335      if (content.length === 0) continue;
336      return { name: candidate, content: content.slice(0, 400 * 1024) };
337    } catch {
338      continue;
339    }
340  }
341  return null;
342}
343 
344/* Tree + file contents                                                */
345 
346export async function getTree(
347  source: GitSource,
348  name: string,
349  dirPath: string,
350  ref: string
351): Promise<TreeEntry[] | null> {
352  const dir = safePath(dirPath);
353  if (source === "github") {
354    const url = dir
355      ? `https://api.github.com/repos/${GITHUB_USER}/${name}/contents/${dir}?ref=${encodeURIComponent(ref)}`
356      : `https://api.github.com/repos/${GITHUB_USER}/${name}/contents/?ref=${encodeURIComponent(ref)}`;
357    const { ok, body } = await fetchJson(url);
358    if (!ok || !Array.isArray(body)) return null;
359    return (body as Array<{ type: string; name: string; path: string; size?: number }>).map((e) => ({
360      name: e.name,
361      path: e.path,
362      type: e.type === "dir" ? "dir" : "file",
363      size: e.type === "dir" ? null : e.size ?? 0,
364    }));
365  }
366  const params = new URLSearchParams({ ref, per_page: "100" });
367  if (dir) params.set("path", dir);
368  const { ok, body } = await fetchJson(
369    `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/tree?${params.toString()}`
370  );
371  if (!ok || !Array.isArray(body)) return null;
372  return (body as Array<{ type: string; name: string; path: string }>).map((e) => ({
373    name: e.name,
374    path: e.path,
375    type: e.type === "tree" ? "dir" : "file",
376    size: null,
377  }));
378}
379 
380const BINARY_EXTENSIONS = new Set([
381  "png","jpg","jpeg","gif","webp","ico","bmp","tiff",
382  "woff","woff2","ttf","otf","eot",
383  "pdf","zip","gz","tar","7z","rar","jar","exe","dll","so","dylib",
384  "mp3","mp4","mkv","mov","avi","webm","flac","wav",
385  "bin","o","a","pyc","class","wasm","db","sqlite","ds_store",
386]);
387 
388export async function getFile(
389  source: GitSource,
390  name: string,
391  filePath: string,
392  ref: string
393): Promise<FileContent | null> {
394  const filePathSafe = safePath(filePath);
395  if (!filePathSafe) return null;
396  const fileName = filePathSafe.split("/").pop() ?? filePathSafe;
397  const ext = fileName.includes(".") ? fileName.split(".").pop()!.toLowerCase() : "";
398 
399  let size = 0;
400  let text: string | null = null;
401  let encoded: string | null = null;
402 
403  if (source === "github") {
404    const { ok, body } = await fetchJson(
405      `https://api.github.com/repos/${GITHUB_USER}/${name}/contents/${filePathSafe}?ref=${encodeURIComponent(ref)}`
406    );
407    if (!ok || !body || typeof body !== "object" || Array.isArray(body)) return null;
408    const b = body as { size?: number; content?: string; encoding?: string };
409    size = b.size ?? 0;
410    if (b.encoding === "base64" && typeof b.content === "string") encoded = b.content.replace(/\n/g, "");
411  } else {
412    const { ok, body } = await fetchJson(
413      `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/files/${encodeURIComponent(filePathSafe)}?ref=${encodeURIComponent(ref)}`
414    );
415    if (!ok || !body || typeof body !== "object") return null;
416    const b = body as { size?: number; content?: string; encoding?: string };
417    size = b.size ?? 0;
418    if (b.encoding === "base64" && typeof b.content === "string") encoded = b.content;
419  }
420 
421  if (size > MAX_FILE_BYTES) {
422    return { name: fileName, path: filePathSafe, size, text: null, isBinary: BINARY_EXTENSIONS.has(ext), tooLarge: true };
423  }
424  if (BINARY_EXTENSIONS.has(ext)) {
425    return { name: fileName, path: filePathSafe, size, text: null, isBinary: true, tooLarge: false };
426  }
427  if (encoded) {
428    try {
429      const buf = Buffer.from(encoded, "base64");
430      if (buf.includes(0)) {
431        return { name: fileName, path: filePathSafe, size, text: null, isBinary: true, tooLarge: false };
432      }
433      text = buf.toString("utf8");
434    } catch {
435      text = null;
436    }
437  }
438  if (text && text.split("\n").length > MAX_LINES) {
439    text = text.split("\n").slice(0, MAX_LINES).join("\n") + `\n\n… truncated at ${MAX_LINES} lines`;
440  }
441  return { name: fileName, path: filePathSafe, size, text, isBinary: text === null, tooLarge: false };
442}
443 
444/* Commits, branches, tags                                             */
445 
446export interface CommitsPage {
447  commits: CommitEntry[];
448  hasMore: boolean;
449  page: number;
450}
451 
452export async function getCommits(
453  source: GitSource,
454  name: string,
455  ref: string,
456  page: number
457): Promise<CommitsPage> {
458  const per = 30;
459  const p = Math.max(1, page);
460  if (source === "github") {
461    const { ok, body } = await fetchJson(
462      `https://api.github.com/repos/${GITHUB_USER}/${name}/commits?sha=${encodeURIComponent(ref)}&per_page=${per + 1}&page=${p}`
463    );
464    if (!ok || !Array.isArray(body)) return { commits: [], hasMore: false, page: p };
465    const list = (body as Array<{
466      sha: string;
467      html_url: string;
468      commit: { message: string; author: { name: string; date: string } };
469    }>).map((c) => ({
470      shortId: c.sha.slice(0, 8),
471      title: (c.commit.message || "").split("\n")[0],
472      authorName: c.commit.author?.name ?? "unknown",
473      authoredAt: c.commit.author?.date ?? "",
474      url: c.html_url,
475    }));
476    return { commits: list.slice(0, per), hasMore: list.length > per, page: p };
477  }
478  const params = new URLSearchParams({
479    ref_name: ref,
480    per_page: String(per + 1),
481    page: String(p),
482  });
483  const { ok, body } = await fetchJson(
484    `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/commits?${params.toString()}`
485  );
486  if (!ok || !Array.isArray(body)) return { commits: [], hasMore: false, page: p };
487  const list = (body as Array<{
488    short_id: string;
489    title: string;
490    author_name: string;
491    authored_date: string;
492    web_url: string;
493  }>).map((c) => ({
494    shortId: c.short_id,
495    title: c.title,
496    authorName: c.author_name,
497    authoredAt: c.authored_date,
498    url: c.web_url,
499  }));
500  return { commits: list.slice(0, per), hasMore: list.length > per, page: p };
501}
502 
503export async function getBranches(source: GitSource, name: string): Promise<BranchEntry[]> {
504  if (source === "github") {
505    const { ok, body } = await fetchJson(
506      `https://api.github.com/repos/${GITHUB_USER}/${name}/branches?per_page=100`
507    );
508    if (!ok || !Array.isArray(body)) return [];
509    return (body as Array<{ name: string }>).map((b) => ({ name: b.name, isDefault: false }));
510  }
511  const { ok, body } = await fetchJson(
512    `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/branches?per_page=100`
513  );
514  if (!ok || !Array.isArray(body)) return [];
515  return (body as Array<{ name: string; default?: boolean }>).map((b) => ({
516    name: b.name,
517    isDefault: !!b.default,
518  }));
519}
520 
521export async function getTags(source: GitSource, name: string): Promise<TagEntry[]> {
522  if (source === "github") {
523    const { ok, body } = await fetchJson(
524      `https://api.github.com/repos/${GITHUB_USER}/${name}/tags?per_page=100`
525    );
526    if (!ok || !Array.isArray(body)) return [];
527    return (body as Array<{ name: string }>).map((t) => ({ name: t.name }));
528  }
529  const { ok, body } = await fetchJson(
530    `https://gitlab.com/api/v4/projects/${gitlabProjectId(name)}/repository/tags?per_page=100`
531  );
532  if (!ok || !Array.isArray(body)) return [];
533  return (body as Array<{ name: string }>).map((t) => ({ name: t.name }));
534}
535 
536export function allTopics(repos: RepoSummary[], limit = 16): string[] {
537  const counts = new Map<string, number>();
538  for (const r of repos) {
539    for (const t of r.topics) counts.set(t, (counts.get(t) ?? 0) + 1);
540  }
541  return [...counts.entries()]
542    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
543    .slice(0, limit)
544    .map(([t]) => t);
545}
546 
547export function nowMs(): number {
548  return Date.now();
549}
550 
551export function formatBytes(bytes: number): string {
552  if (!bytes || bytes < 1) return "0 B";
553  const units = ["B", "KB", "MB", "GB"];
554  let v = bytes;
555  let i = 0;
556  while (v >= 1024 && i < units.length - 1) {
557    v /= 1024;
558    i++;
559  }
560  return `${v >= 10 || i === 0 ? Math.round(v) : v.toFixed(1)} ${units[i]}`;
561}
562