@algochad/archcoder 2.0.2

package/server/lib/github/pr-status.js

@@ -0,0 +1,478 @@
+import { getRemotes, getStatus } from '../git/index.js';
+import { resolveGitHubRepoFromDirectory } from './repo/index.js';
+
+const REPO_DEFAULT_BRANCH_TTL_MS = 5 * 60_000;
+const defaultBranchCache = new Map();
+const repoMetadataCache = new Map();
+
+const normalizeText = (value) => typeof value === 'string' ? value.trim() : '';
+const normalizeLower = (value) => normalizeText(value).toLowerCase();
+const normalizeRepoKey = (owner, repo) => {
+  const normalizedOwner = normalizeLower(owner);
+  const normalizedRepo = normalizeLower(repo);
+  if (!normalizedOwner || !normalizedRepo) {
+    return '';
+  }
+  return `${normalizedOwner}/${normalizedRepo}`;
+};
+const parseTrackingRemoteName = (trackingBranch) => {
+  const normalized = normalizeText(trackingBranch);
+  if (!normalized) {
+    return '';
+  }
+  const slashIndex = normalized.indexOf('/');
+  if (slashIndex <= 0) {
+    return '';
+  }
+  return normalized.slice(0, slashIndex).trim();
+};
+
+const pushUnique = (collection, value, keyFn = normalizeLower) => {
+  const normalizedValue = normalizeText(value);
+  if (!normalizedValue) {
+    return;
+  }
+  const nextKey = keyFn(normalizedValue);
+  if (!nextKey) {
+    return;
+  }
+  if (collection.some((item) => keyFn(item) === nextKey)) {
+    return;
+  }
+  collection.push(normalizedValue);
+};
+
+const rankRemoteNames = (remoteNames, explicitRemoteName, trackingRemoteName) => {
+  const ranked = [];
+  pushUnique(ranked, explicitRemoteName);
+
+  if (trackingRemoteName) {
+    pushUnique(ranked, trackingRemoteName);
+  }
+
+  pushUnique(ranked, 'origin');
+  pushUnique(ranked, 'upstream');
+  remoteNames.forEach((name) => pushUnique(ranked, name));
+  return ranked;
+};
+
+const getHeadOwner = (pr) => {
+  const repoOwner = normalizeText(pr?.head?.repo?.owner?.login);
+  if (repoOwner) {
+    return repoOwner;
+  }
+  const userOwner = normalizeText(pr?.head?.user?.login);
+  if (userOwner) {
+    return userOwner;
+  }
+  const headLabel = normalizeText(pr?.head?.label);
+  const separatorIndex = headLabel.indexOf(':');
+  if (separatorIndex > 0) {
+    return headLabel.slice(0, separatorIndex).trim();
+  }
+  return '';
+};
+
+const getHeadRepoKey = (pr, fallbackRepoName) => {
+  const repoOwner = normalizeText(pr?.head?.repo?.owner?.login);
+  const repoName = normalizeText(pr?.head?.repo?.name);
+  if (repoOwner && repoName) {
+    return normalizeRepoKey(repoOwner, repoName);
+  }
+  const headLabel = normalizeText(pr?.head?.label);
+  const separatorIndex = headLabel.indexOf(':');
+  if (separatorIndex > 0) {
+    const labelOwner = headLabel.slice(0, separatorIndex).trim();
+    if (labelOwner && fallbackRepoName) {
+      return normalizeRepoKey(labelOwner, fallbackRepoName);
+    }
+  }
+  return '';
+};
+
+const buildSourceMatcher = (sourceCandidates) => {
+  const repoRank = new Map();
+  const ownerRank = new Map();
+
+  sourceCandidates.forEach((candidate, index) => {
+    const repoKey = normalizeRepoKey(candidate.repo?.owner, candidate.repo?.repo);
+    if (repoKey && !repoRank.has(repoKey)) {
+      repoRank.set(repoKey, index);
+    }
+    const owner = normalizeLower(candidate.repo?.owner);
+    if (owner && !ownerRank.has(owner)) {
+      ownerRank.set(owner, index);
+    }
+  });
+
+  const matches = (pr, fallbackRepoName) => {
+    const repoKey = getHeadRepoKey(pr, fallbackRepoName);
+    if (repoKey && repoRank.has(repoKey)) {
+      return true;
+    }
+    const owner = normalizeLower(getHeadOwner(pr));
+    return Boolean(owner) && ownerRank.has(owner);
+  };
+
+  const compare = (left, right, fallbackRepoName) => {
+    const leftRepoRank = repoRank.get(getHeadRepoKey(left, fallbackRepoName));
+    const rightRepoRank = repoRank.get(getHeadRepoKey(right, fallbackRepoName));
+    const leftRepoScore = typeof leftRepoRank === 'number' ? leftRepoRank : Number.POSITIVE_INFINITY;
+    const rightRepoScore = typeof rightRepoRank === 'number' ? rightRepoRank : Number.POSITIVE_INFINITY;
+    if (leftRepoScore !== rightRepoScore) {
+      return leftRepoScore - rightRepoScore;
+    }
+
+    const leftOwnerRank = ownerRank.get(normalizeLower(getHeadOwner(left)));
+    const rightOwnerRank = ownerRank.get(normalizeLower(getHeadOwner(right)));
+    const leftOwnerScore = typeof leftOwnerRank === 'number' ? leftOwnerRank : Number.POSITIVE_INFINITY;
+    const rightOwnerScore = typeof rightOwnerRank === 'number' ? rightOwnerRank : Number.POSITIVE_INFINITY;
+    if (leftOwnerScore !== rightOwnerScore) {
+      return leftOwnerScore - rightOwnerScore;
+    }
+
+    return 0;
+  };
+
+  return { matches, compare };
+};
+
+const getRepoDefaultBranch = async (octokit, repo) => {
+  const repoKey = normalizeRepoKey(repo?.owner, repo?.repo);
+  if (!repoKey) {
+    return null;
+  }
+
+  const cached = defaultBranchCache.get(repoKey);
+  if (cached && Date.now() - cached.fetchedAt < REPO_DEFAULT_BRANCH_TTL_MS) {
+    return cached.defaultBranch;
+  }
+
+  try {
+    const response = await octokit.rest.repos.get({
+      owner: repo.owner,
+      repo: repo.repo,
+    });
+    const defaultBranch = normalizeText(response?.data?.default_branch) || null;
+    defaultBranchCache.set(repoKey, {
+      defaultBranch,
+      fetchedAt: Date.now(),
+    });
+    return defaultBranch;
+  } catch {
+    return null;
+  }
+};
+
+const getRepoMetadata = async (octokit, repo) => {
+  const repoKey = normalizeRepoKey(repo?.owner, repo?.repo);
+  if (!repoKey) {
+    return null;
+  }
+
+  const cached = repoMetadataCache.get(repoKey);
+  if (cached && Date.now() - cached.fetchedAt < REPO_DEFAULT_BRANCH_TTL_MS) {
+    return cached.data;
+  }
+
+  try {
+    const response = await octokit.rest.repos.get({
+      owner: repo.owner,
+      repo: repo.repo,
+    });
+    const data = response?.data ?? null;
+    repoMetadataCache.set(repoKey, {
+      data,
+      fetchedAt: Date.now(),
+    });
+    return data;
+  } catch (error) {
+    if (error?.status === 403 || error?.status === 404) {
+      repoMetadataCache.set(repoKey, {
+        data: null,
+        fetchedAt: Date.now(),
+      });
+      return null;
+    }
+    throw error;
+  }
+};
+
+const resolveRemoteCandidates = async (directory, rankedRemoteNames) => {
+  const results = [];
+  const seenRepoKeys = new Set();
+
+  for (const remoteName of rankedRemoteNames) {
+    const resolved = await resolveGitHubRepoFromDirectory(directory, remoteName).catch(() => ({ repo: null }));
+    const repo = resolved?.repo || null;
+    const repoKey = normalizeRepoKey(repo?.owner, repo?.repo);
+    if (!repo || !repoKey || seenRepoKeys.has(repoKey)) {
+      continue;
+    }
+    seenRepoKeys.add(repoKey);
+    results.push({
+      remoteName,
+      repo,
+    });
+  }
+
+  return results;
+};
+
+const expandRepoNetwork = async (octokit, candidates) => {
+  const expanded = [];
+  const seenRepoKeys = new Set();
+
+  const pushCandidate = (repo, remoteName, priority) => {
+    const repoKey = normalizeRepoKey(repo?.owner, repo?.repo);
+    if (!repoKey || seenRepoKeys.has(repoKey)) {
+      return;
+    }
+    seenRepoKeys.add(repoKey);
+    expanded.push({ repo, remoteName, priority });
+  };
+
+  for (const candidate of candidates) {
+    const metadata = await getRepoMetadata(octokit, candidate.repo);
+    if (!metadata) {
+      continue;
+    }
+
+    pushCandidate(candidate.repo, candidate.remoteName, candidate.priority);
+
+    const parent = metadata?.parent;
+    if (parent?.owner?.login && parent?.name) {
+      pushCandidate({
+        owner: parent.owner.login,
+        repo: parent.name,
+        url: parent.html_url || `https://github.com/${parent.owner.login}/${parent.name}`,
+      }, candidate.remoteName, candidate.priority + 0.1);
+    }
+
+    const source = metadata?.source;
+    if (source?.owner?.login && source?.name) {
+      pushCandidate({
+        owner: source.owner.login,
+        repo: source.name,
+        url: source.html_url || `https://github.com/${source.owner.login}/${source.name}`,
+      }, candidate.remoteName, candidate.priority + 0.2);
+    }
+  }
+
+  return expanded.sort((left, right) => left.priority - right.priority);
+};
+
+const safeListPulls = async (octokit, options) => {
+  try {
+    const response = await octokit.rest.pulls.list(options);
+    return Array.isArray(response?.data) ? response.data : [];
+  } catch (error) {
+    if (error?.status === 404 || error?.status === 403) {
+      return [];
+    }
+    throw error;
+  }
+};
+
+const parseRepoFromApiUrl = (value) => {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return null;
+  }
+  try {
+    const url = new URL(normalized);
+    const parts = url.pathname.replace(/^\/+/, '').split('/').filter(Boolean);
+    if (parts.length < 2 || parts[0] !== 'repos') {
+      return null;
+    }
+    const owner = parts[1];
+    const repo = parts[2];
+    if (!owner || !repo) {
+      return null;
+    }
+    return { owner, repo };
+  } catch {
+    return null;
+  }
+};
+
+const searchFallbackPr = async ({ octokit, branch, repoNames }) => {
+  const normalizedRepoNames = new Set(repoNames.map((name) => normalizeLower(name)).filter(Boolean));
+
+  for (const state of ['open', 'closed']) {
+    let response;
+    try {
+      response = await octokit.rest.search.issuesAndPullRequests({
+        q: `is:pr state:${state} head:${branch}`,
+        per_page: 20,
+      });
+    } catch (error) {
+      if (error?.status === 403 || error?.status === 404) {
+        continue;
+      }
+      throw error;
+    }
+
+    const items = Array.isArray(response?.data?.items) ? response.data.items : [];
+    for (const item of items) {
+      const repo = parseRepoFromApiUrl(item?.repository_url);
+      if (!repo) {
+        continue;
+      }
+      if (normalizedRepoNames.size > 0 && !normalizedRepoNames.has(normalizeLower(repo.repo))) {
+        continue;
+      }
+      try {
+        const prResponse = await octokit.rest.pulls.get({
+          owner: repo.owner,
+          repo: repo.repo,
+          pull_number: item.number,
+        });
+        const pr = prResponse?.data;
+        if (!pr || normalizeText(pr.head?.ref) !== branch) {
+          continue;
+        }
+        return {
+          repo: {
+            owner: repo.owner,
+            repo: repo.repo,
+            url: `https://github.com/${repo.owner}/${repo.repo}`,
+          },
+          pr,
+        };
+      } catch (error) {
+        if (error?.status === 403 || error?.status === 404) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+
+  return null;
+};
+
+const findFirstMatchingPr = async ({ octokit, target, branch, sourceCandidates }) => {
+  const matcher = buildSourceMatcher(sourceCandidates);
+  const sourceOwners = [];
+  sourceCandidates.forEach((candidate) => pushUnique(sourceOwners, candidate.repo?.owner));
+
+  const pickPreferred = (prs) => prs
+    .filter((pr) => normalizeText(pr?.head?.ref) === branch)
+    .filter((pr) => matcher.matches(pr, target.repo.repo))
+    .sort((left, right) => matcher.compare(left, right, target.repo.repo))[0] ?? null;
+
+  for (const state of ['open', 'closed']) {
+    for (const owner of sourceOwners) {
+      const directCandidates = await safeListPulls(octokit, {
+        owner: target.repo.owner,
+        repo: target.repo.repo,
+        state,
+        head: `${owner}:${branch}`,
+        per_page: 100,
+      });
+      const direct = pickPreferred(directCandidates);
+      if (direct) {
+        return direct;
+      }
+    }
+
+    const fallbackCandidates = await safeListPulls(octokit, {
+      owner: target.repo.owner,
+      repo: target.repo.repo,
+      state,
+      per_page: 100,
+    });
+    const fallback = pickPreferred(fallbackCandidates);
+    if (fallback) {
+      return fallback;
+    }
+  }
+
+  return null;
+};
+
+export async function resolveGitHubPrStatus({ octokit, directory, branch, remoteName }) {
+  const normalizedBranch = normalizeText(branch);
+  const normalizedRemoteName = normalizeText(remoteName) || 'origin';
+
+  const [status, remotes] = await Promise.all([
+    getStatus(directory).catch(() => null),
+    getRemotes(directory).catch(() => []),
+  ]);
+
+  const trackingRemoteName = parseTrackingRemoteName(status?.tracking);
+  const rankedRemoteNames = rankRemoteNames(
+    Array.isArray(remotes) ? remotes.map((remote) => remote?.name).filter(Boolean) : [],
+    normalizedRemoteName,
+    trackingRemoteName,
+  );
+
+  const resolvedRemoteTargets = await resolveRemoteCandidates(directory, rankedRemoteNames.slice(0, 3));
+  const resolvedTargets = await expandRepoNetwork(
+    octokit,
+    resolvedRemoteTargets.map((target, index) => ({ ...target, priority: index })),
+  );
+  if (resolvedTargets.length === 0) {
+    return {
+      repo: null,
+      pr: null,
+      defaultBranch: null,
+      resolvedRemoteName: null,
+    };
+  }
+
+  const sourceCandidates = resolvedTargets.slice();
+
+  let fallbackRepo = resolvedTargets[0].repo;
+  let fallbackRemoteName = resolvedTargets[0].remoteName;
+  let fallbackDefaultBranch = await getRepoDefaultBranch(octokit, fallbackRepo);
+
+  for (const target of resolvedTargets) {
+    const defaultBranch = await getRepoDefaultBranch(octokit, target.repo);
+    if (!fallbackRepo) {
+      fallbackRepo = target.repo;
+      fallbackRemoteName = target.remoteName;
+      fallbackDefaultBranch = defaultBranch;
+    }
+    if (defaultBranch && defaultBranch === normalizedBranch) {
+      continue;
+    }
+
+    const pr = await findFirstMatchingPr({
+      octokit,
+      target,
+      branch: normalizedBranch,
+      sourceCandidates,
+    });
+    if (pr) {
+      return {
+        repo: target.repo,
+        pr,
+        defaultBranch,
+        resolvedRemoteName: target.remoteName,
+      };
+    }
+  }
+
+  const fallbackSearch = await searchFallbackPr({
+    octokit,
+    branch: normalizedBranch,
+    repoNames: resolvedTargets.map((target) => target.repo.repo),
+  });
+  if (fallbackSearch) {
+    return {
+      repo: fallbackSearch.repo,
+      pr: fallbackSearch.pr,
+      defaultBranch: await getRepoDefaultBranch(octokit, fallbackSearch.repo),
+      resolvedRemoteName: null,
+    };
+  }
+
+  return {
+    repo: fallbackRepo,
+    pr: null,
+    defaultBranch: fallbackDefaultBranch,
+    resolvedRemoteName: fallbackRemoteName,
+  };
+}

package/server/lib/github/repo/index.js

@@ -0,0 +1,55 @@
+import { getRemoteUrl } from '../../git/index.js';
+
+export const parseGitHubRemoteUrl = (raw) => {
+  if (typeof raw !== 'string') {
+    return null;
+  }
+  const value = raw.trim();
+  if (!value) {
+    return null;
+  }
+
+  // git@github.com:OWNER/REPO.git
+  if (value.startsWith('git@github.com:')) {
+    const rest = value.slice('git@github.com:'.length);
+    const cleaned = rest.endsWith('.git') ? rest.slice(0, -4) : rest;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  }
+
+  // ssh://git@github.com/OWNER/REPO.git
+  if (value.startsWith('ssh://git@github.com/')) {
+    const rest = value.slice('ssh://git@github.com/'.length);
+    const cleaned = rest.endsWith('.git') ? rest.slice(0, -4) : rest;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  }
+
+  // https://github.com/OWNER/REPO(.git)
+  try {
+    const url = new URL(value);
+    if (url.hostname !== 'github.com') {
+      return null;
+    }
+    const path = url.pathname.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleaned = path.endsWith('.git') ? path.slice(0, -4) : path;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  } catch {
+    return null;
+  }
+};
+
+export async function resolveGitHubRepoFromDirectory(directory, remoteName = 'origin') {
+  const remoteUrl = await getRemoteUrl(directory, remoteName).catch(() => null);
+  if (!remoteUrl) {
+    return { repo: null, remoteUrl: null };
+  }
+  return {
+    repo: parseGitHubRemoteUrl(remoteUrl),
+    remoteUrl,
+  };
+}