@remogram/provider-gitea-api 0.1.0-beta.0

package/index.js

@@ -0,0 +1,293 @@
+import {
+  fetchJson,
+  sanitizeField,
+  sanitizeUrl,
+  assertGitRef,
+  assertGitRemote,
+  gitRevParse,
+  gitCurrentBranch,
+  gitAheadBehind,
+  ERROR_CODES,
+  forgeError,
+} from '@remogram/core';
+const PUBLIC_GITEA_HOST = 'gitea.com';
+const PUBLIC_GITEA_API = 'https://gitea.com/api/v1';
+const AUTH_CAPABILITIES = [
+  'repo_status',
+  'ref_compare',
+  'pr_status',
+  'pr_checks',
+  'merge_plan',
+  'sync_plan',
+];
+
+const STRUCTURED_COMMANDS = AUTH_CAPABILITIES.map((name) => ({ name, implemented: true }));
+
+export function giteaToken() {
+  return process.env.GITEA_TOKEN || null;
+}
+
+export function requireToken() {
+  const token = giteaToken();
+  if (!token) {
+    throw Object.assign(new Error('GITEA_TOKEN not set'), {
+      forgeError: forgeError(ERROR_CODES.UNAUTHENTICATED_PROVIDER, 'GITEA_TOKEN not set'),
+    });
+  }
+  return token;
+}
+
+function configuredHost(config) {
+  if (!config.baseUrl) return null;
+  try {
+    return new URL(config.baseUrl).host;
+  } catch {
+    throw Object.assign(new Error('Invalid baseUrl for gitea-api'), {
+      forgeError: forgeError(ERROR_CODES.CONFIG_INVALID, 'Invalid baseUrl for gitea-api provider'),
+    });
+  }
+}
+
+function configOrigin(config) {
+  if (!config.baseUrl) return null;
+  try {
+    return new URL(config.baseUrl).origin;
+  } catch {
+    throw Object.assign(new Error('Invalid baseUrl for gitea-api'), {
+      forgeError: forgeError(ERROR_CODES.CONFIG_INVALID, 'Invalid baseUrl for gitea-api provider'),
+    });
+  }
+}
+
+export function apiBase(config, parsed = {}) {
+  const remoteHost = parsed.host || configuredHost(config);
+  if (!remoteHost) {
+    throw Object.assign(new Error('remote host required for gitea-api'), {
+      forgeError: forgeError(ERROR_CODES.CONFIG_INVALID, 'remote host required for gitea-api provider'),
+    });
+  }
+
+  const host = remoteHost.toLowerCase();
+  const configured = configuredHost(config);
+  if (host === PUBLIC_GITEA_HOST) {
+    if (configured && configured.toLowerCase() !== PUBLIC_GITEA_HOST) {
+      const message = 'gitea.com remotes may use only https://gitea.com for API requests';
+      throw Object.assign(new Error(message), {
+        forgeError: forgeError(ERROR_CODES.UNTRUSTED_BASE_URL, message),
+      });
+    }
+    return PUBLIC_GITEA_API;
+  }
+
+  if (!configured) {
+    throw Object.assign(new Error('baseUrl required for gitea-api'), {
+      forgeError: forgeError(ERROR_CODES.CONFIG_INVALID, 'baseUrl required for gitea-api provider'),
+    });
+  }
+
+  if (configured.toLowerCase() !== host) {
+    const message = `Gitea API host must match remote host ${remoteHost}`;
+    throw Object.assign(new Error(message), {
+      forgeError: forgeError(ERROR_CODES.UNTRUSTED_BASE_URL, message),
+    });
+  }
+
+  const origin = configOrigin(config) || `https://${remoteHost}`;
+  return `${origin.replace(/\/$/, '')}/api/v1`;
+}
+
+export function authHeaders(token) {
+  return { Authorization: `token ${token}`, Accept: 'application/json' };
+}
+
+export function repoApiPath(config, ...segments) {
+  const owner = encodeURIComponent(config.owner);
+  const repo = encodeURIComponent(config.repo);
+  const base = `/repos/${owner}/${repo}`;
+  if (!segments.length) return base;
+  return `${base}/${segments.map((s) => encodeURIComponent(String(s))).join('/')}`;
+}
+
+export async function giteaFetch(config, parsed, path, options = {}) {
+  const token = requireToken();
+  const url = `${apiBase(config, parsed)}${path}`;
+  return fetchJson(url, {
+    ...options,
+    headers: { ...authHeaders(token), ...(options.headers || {}) },
+  });
+}
+
+export async function repoStatus(ctx) {
+  const token = giteaToken();
+  let defaultBranch = null;
+  if (token) {
+    const repo = await giteaFetch(ctx.config, ctx.parsed, repoApiPath(ctx.config));
+    defaultBranch = sanitizeField(repo.default_branch);
+  }
+  return {
+    auth_present: Boolean(token),
+    auth_env: token ? 'GITEA_TOKEN' : null,
+    capabilities: token ? AUTH_CAPABILITIES : ['repo_status'],
+    default_branch: defaultBranch,
+  };
+}
+
+export function providerCapabilities() {
+  return {
+    commands: STRUCTURED_COMMANDS,
+    auth_envs: ['GITEA_TOKEN'],
+    check_sources: ['commit_statuses'],
+    mergeability_confidence: 'direct',
+    host_binding: 'verified_remote_host',
+    pagination: 'first_page_only',
+    write_support: false,
+  };
+}
+
+export async function refsCompare(ctx, baseRef, headRef) {
+  requireToken();
+  assertGitRef(baseRef, 'base');
+  assertGitRef(headRef, 'head');
+  const baseSha = gitRevParse(ctx.cwd, baseRef);
+  const headSha = gitRevParse(ctx.cwd, headRef);
+  if (!baseSha || !headSha) {
+    throw Object.assign(new Error('Missing ref'), {
+      forgeError: forgeError(ERROR_CODES.MISSING_REF, 'Could not resolve base or head ref'),
+    });
+  }
+  const counts = gitAheadBehind(ctx.cwd, baseSha, headSha);
+  return {
+    base_ref: sanitizeField(baseRef),
+    base_sha: baseSha,
+    head_ref: sanitizeField(headRef),
+    head_sha: headSha,
+    ...counts,
+  };
+}
+
+export async function getPull(ctx, { number }) {
+  if (number == null) {
+    throw Object.assign(new Error('--number required'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, 'Provide --number for PR lookup'),
+    });
+  }
+  return giteaFetch(ctx.config, ctx.parsed, repoApiPath(ctx.config, 'pulls', number));
+}
+
+function mergeability(pr) {
+  if (pr.mergeable === true) return 'clean';
+  if (pr.mergeable === false) return 'conflicted';
+  return 'unknown';
+}
+
+export async function prView(ctx, opts) {
+  const pr = await getPull(ctx, opts);
+  return {
+    pr_number: pr.number,
+    url: sanitizeUrl(pr.html_url ?? pr.url),
+    title: sanitizeField(pr.title),
+    state: sanitizeField(pr.state),
+    base_ref: sanitizeField(pr.base?.ref),
+    base_sha: sanitizeField(pr.base?.sha),
+    head_ref: sanitizeField(pr.head?.ref),
+    head_sha: sanitizeField(pr.head?.sha),
+    mergeability: mergeability(pr),
+  };
+}
+
+export async function prChecks(ctx, opts) {
+  requireToken();
+  let sha;
+  if (opts.ref) {
+    assertGitRef(opts.ref, 'ref');
+    sha = gitRevParse(ctx.cwd, opts.ref);
+    if (!sha) {
+      throw Object.assign(new Error('Missing ref'), {
+        forgeError: forgeError(ERROR_CODES.MISSING_REF, `Could not resolve ref ${opts.ref}`),
+      });
+    }
+  } else {
+    const pr = await getPull(ctx, opts);
+    sha = pr.head?.sha;
+  }
+  if (!sha) {
+    throw Object.assign(new Error('No SHA'), {
+      forgeError: forgeError(ERROR_CODES.MISSING_REF, 'Could not determine head SHA for checks'),
+    });
+  }
+  const statuses = await giteaFetch(
+    ctx.config,
+    ctx.parsed,
+    repoApiPath(ctx.config, 'commits', sha, 'statuses'),
+  );
+  const mapped = (statuses || []).map((s) => ({
+    context: sanitizeField(s.context),
+    state: sanitizeField(s.state),
+    description: sanitizeField(s.description),
+  }));
+  const conclusion = summarizeChecks(mapped);
+  return { head_sha: sha, check_conclusion: conclusion, statuses: mapped };
+}
+
+function summarizeChecks(statuses) {
+  if (!statuses.length) return 'missing';
+  if (statuses.some((s) => s.state === 'failure' || s.state === 'error')) return 'failure';
+  if (statuses.some((s) => s.state === 'pending')) return 'pending';
+  if (statuses.every((s) => s.state === 'success')) return 'success';
+  return 'unknown';
+}
+
+export async function mergePlan(ctx, opts) {
+  const view = await prView(ctx, opts);
+  const checks = await prChecks(ctx, { number: view.pr_number });
+  const blockers = [];
+  if (view.mergeability === 'conflicted') blockers.push('merge_conflict');
+  if (view.state !== 'open') blockers.push('pr_not_open');
+  if (checks.check_conclusion === 'failure') blockers.push('checks_failed');
+  if (checks.check_conclusion === 'missing') blockers.push('checks_missing');
+  if (checks.check_conclusion === 'pending') blockers.push('checks_pending');
+  return {
+    pr_number: view.pr_number,
+    mergeability: view.mergeability,
+    checks_conclusion: checks.check_conclusion,
+    blockers,
+  };
+}
+
+export async function syncPlan(ctx, remoteName = 'origin') {
+  assertGitRemote(remoteName, 'remote');
+  const localSha = gitRevParse(ctx.cwd, 'HEAD');
+  const branch = gitCurrentBranch(ctx.cwd);
+  let remoteSha = null;
+  if (branch && branch !== 'HEAD') {
+    remoteSha = gitRevParse(ctx.cwd, `${remoteName}/${branch}`);
+  }
+  const blockers = [];
+  let diverged = false;
+  if (localSha && remoteSha && localSha !== remoteSha) {
+    const { ahead_by, behind_by } = gitAheadBehind(ctx.cwd, remoteSha, localSha);
+    if (ahead_by > 0 && behind_by > 0) {
+      diverged = true;
+      blockers.push('divergent_remotes');
+    }
+  }
+  if (!remoteSha) blockers.push('missing_remote_ref');
+  return {
+    remote: sanitizeField(remoteName),
+    local_sha: localSha,
+    remote_sha: remoteSha,
+    diverged,
+    blockers,
+  };
+}
+
+export const provider = {
+  id: 'gitea-api',
+  providerCapabilities,
+  repoStatus,
+  refsCompare,
+  prView,
+  prChecks,
+  mergePlan,
+  syncPlan,
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@remogram/provider-gitea-api",
+  "version": "0.1.0-beta.0",
+  "description": "Gitea REST API forge provider for remogram",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/attebury/remogram.git",
+    "directory": "packages/provider-gitea-api"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "*.js"
+  ],
+  "exports": {
+    ".": "./index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@remogram/core": "0.1.0-beta.0"
+  }
+}