import { GitHubError, NotFoundError, RateLimitError } from "./errors.js";

const META_OWNER = "TMHSDigital";

const META_REPO = "Developer-Tools-Directory";

const CACHE_TTL_MS = 5 * 60 * 1000;

interface CacheEntry<T> {

data: T;

expiresAt: number;

}

const cache = new Map<string, CacheEntry<unknown>>();

function cached<T>(key: string): T | undefined {

const entry = cache.get(key);

if (entry && Date.now() < entry.expiresAt) return entry.data as T;

return undefined;

}

function store<T>(key: string, data: T): void {

cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS });

}

function buildHeaders(): Record<string, string> {

const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;

const headers: Record<string, string> = {

Accept: "application/vnd.github+json",

"User-Agent": "devtools-mcp/0.1.0",

"X-GitHub-Api-Version": "2022-11-28",

};

if (token) headers["Authorization"] = `Bearer ${token}`;

return headers;

}

export async function githubFetch<T>(path: string): Promise<T> {

const hit = cached<T>(`api:${path}`);

if (hit !== undefined) return hit;

const url = `https://api.github.com${path}`;

const res = await fetch(url, { headers: buildHeaders() });

if (res.status === 404) throw new NotFoundError(path);

if (res.status === 403 || res.status === 429) throw new RateLimitError();

if (!res.ok) {

throw new GitHubError(`GitHub API ${res.status} for ${path}`, res.status, path);

}

const data = (await res.json()) as T;

store(`api:${path}`, data);

return data;

}

export async function rawFetch(

owner: string,

repo: string,

filePath: string,

ref = "main",

): Promise<string> {

const key = `raw:${owner}/${repo}/${ref}/${filePath}`;

const hit = cached<string>(key);

if (hit !== undefined) return hit;

// Local mode: if DEVTOOLS_META_ROOT is set and this is the meta-repo, read from disk.

const metaRoot = process.env.DEVTOOLS_META_ROOT;

if (metaRoot && owner === META_OWNER && repo === META_REPO) {

const { readFile } = await import("fs/promises");

const { join } = await import("path");

const text = await readFile(join(metaRoot, filePath), "utf-8");

store(key, text);

return text;

}

const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath}`;

const res = await fetch(url, { headers: buildHeaders() });

if (res.status === 404) throw new NotFoundError(`${owner}/${repo}/${filePath}`);

if (res.status === 403 || res.status === 429) throw new RateLimitError();

if (!res.ok) {

throw new GitHubError(

`Raw fetch ${res.status} for ${owner}/${repo}/${filePath}`,

res.status,

);

}

const text = await res.text();

store(key, text);

return text;

}

export function errorResponse(error: unknown): {

content: Array<{ type: "text"; text: string }>;

isError: true;

} {

const message =

error instanceof Error ? error.message : "An unknown error occurred.";

return { content: [{ type: "text", text: message }], isError: true };

}

export function extractStandardsVersion(content: string): string | null {

const match = content.match(/<!--\s*standards-version:\s*([\d.]+)\s*-->/);

return match?.[1] ?? null;

}

export type RegistryEntry = {

name: string;

repo: string;

slug: string;

description: string;

type: "cursor-plugin" | "mcp-server";

homepage: string;

skills: number;

rules: number;

mcpTools: number;

extras: Record<string, unknown>;

topics: string[];

status: string;

version: string;

language: string;

license: string;

pagesType: string;

hasCI: boolean;

npm?: string;

};

export async function fetchRegistry(): Promise<RegistryEntry[]> {

const raw = await rawFetch(META_OWNER, META_REPO, "registry.json");

return JSON.parse(raw) as RegistryEntry[];

}

export async function fetchStandardsVersion(): Promise<string> {

const raw = await rawFetch(META_OWNER, META_REPO, "STANDARDS_VERSION");

return raw.trim();

}

export async function githubWrite<T>(

path: string,

method: "POST" | "PUT" | "PATCH" | "DELETE",

body?: unknown,

): Promise<T> {

const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;

if (!token) {

throw new GitHubError(

"GH_TOKEN or GITHUB_TOKEN is required for write operations",

401,

path,

);

}

const url = `https://api.github.com${path}`;

const opts: RequestInit = {

method,

headers: { ...buildHeaders(), "Content-Type": "application/json" },

};

if (body !== undefined) opts.body = JSON.stringify(body);

const res = await fetch(url, opts);

if (res.status === 404) throw new NotFoundError(path);

if (res.status === 403 || res.status === 429) throw new RateLimitError();

if (res.status === 204) return {} as T;

if (!res.ok) {

const errText = await res.text().catch(() => "");

throw new GitHubError(

`GitHub ${method} ${res.status} for ${path}: ${errText}`,

res.status,

path,

);

}

return res.json() as Promise<T>;

}