init

utils/detectRepository.ts

@@ -0,0 +1,178 @@
+import { getCwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+import { getRemoteUrl } from './git.js'
+
+export type ParsedRepository = {
+  host: string
+  owner: string
+  name: string
+}
+
+const repositoryWithHostCache = new Map<string, ParsedRepository | null>()
+
+export function clearRepositoryCaches(): void {
+  repositoryWithHostCache.clear()
+}
+
+export async function detectCurrentRepository(): Promise<string | null> {
+  const result = await detectCurrentRepositoryWithHost()
+  if (!result) return null
+  // Only return results for github.com to avoid breaking downstream consumers
+  // that assume the result is a github.com repository.
+  // Use detectCurrentRepositoryWithHost() for GHE support.
+  if (result.host !== 'github.com') return null
+  return `${result.owner}/${result.name}`
+}
+
+/**
+ * Like detectCurrentRepository, but also returns the host (e.g. "github.com"
+ * or a GHE hostname). Callers that need to construct URLs against a specific
+ * GitHub host should use this variant.
+ */
+export async function detectCurrentRepositoryWithHost(): Promise<ParsedRepository | null> {
+  const cwd = getCwd()
+
+  if (repositoryWithHostCache.has(cwd)) {
+    return repositoryWithHostCache.get(cwd) ?? null
+  }
+
+  try {
+    const remoteUrl = await getRemoteUrl()
+    logForDebugging(`Git remote URL: ${remoteUrl}`)
+    if (!remoteUrl) {
+      logForDebugging('No git remote URL found')
+      repositoryWithHostCache.set(cwd, null)
+      return null
+    }
+
+    const parsed = parseGitRemote(remoteUrl)
+    logForDebugging(
+      `Parsed repository: ${parsed ? `${parsed.host}/${parsed.owner}/${parsed.name}` : null} from URL: ${remoteUrl}`,
+    )
+    repositoryWithHostCache.set(cwd, parsed)
+    return parsed
+  } catch (error) {
+    logForDebugging(`Error detecting repository: ${error}`)
+    repositoryWithHostCache.set(cwd, null)
+    return null
+  }
+}
+
+/**
+ * Synchronously returns the cached github.com repository for the current cwd
+ * as "owner/name", or null if it hasn't been resolved yet or the host is not
+ * github.com. Call detectCurrentRepository() first to populate the cache.
+ *
+ * Callers construct github.com URLs, so GHE hosts are filtered out here.
+ */
+export function getCachedRepository(): string | null {
+  const parsed = repositoryWithHostCache.get(getCwd())
+  if (!parsed || parsed.host !== 'github.com') return null
+  return `${parsed.owner}/${parsed.name}`
+}
+
+/**
+ * Parses a git remote URL into host, owner, and name components.
+ * Accepts any host (github.com, GHE instances, etc.).
+ *
+ * Supports:
+ *   https://host/owner/repo.git
+ *   git@host:owner/repo.git
+ *   ssh://git@host/owner/repo.git
+ *   git://host/owner/repo.git
+ *   https://host/owner/repo (no .git)
+ *
+ * Note: repo names can contain dots (e.g., cc.kurs.web)
+ */
+export function parseGitRemote(input: string): ParsedRepository | null {
+  const trimmed = input.trim()
+
+  // SSH format: git@host:owner/repo.git
+  const sshMatch = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/)
+  if (sshMatch?.[1] && sshMatch[2] && sshMatch[3]) {
+    if (!looksLikeRealHostname(sshMatch[1])) return null
+    return {
+      host: sshMatch[1],
+      owner: sshMatch[2],
+      name: sshMatch[3],
+    }
+  }
+
+  // URL format: https://host/owner/repo.git, ssh://git@host/owner/repo, git://host/owner/repo
+  const urlMatch = trimmed.match(
+    /^(https?|ssh|git):\/\/(?:[^@]+@)?([^/:]+(?::\d+)?)\/([^/]+)\/([^/]+?)(?:\.git)?$/,
+  )
+  if (urlMatch?.[1] && urlMatch[2] && urlMatch[3] && urlMatch[4]) {
+    const protocol = urlMatch[1]
+    const hostWithPort = urlMatch[2]
+    const hostWithoutPort = hostWithPort.split(':')[0] ?? ''
+    if (!looksLikeRealHostname(hostWithoutPort)) return null
+    // Only preserve port for HTTPS — SSH/git ports are not usable for constructing
+    // web URLs (e.g. ssh://git@ghe.corp.com:2222 → port 2222 is SSH, not HTTPS).
+    const host =
+      protocol === 'https' || protocol === 'http'
+        ? hostWithPort
+        : hostWithoutPort
+    return {
+      host,
+      owner: urlMatch[3],
+      name: urlMatch[4],
+    }
+  }
+
+  return null
+}
+
+/**
+ * Parses a git remote URL or "owner/repo" string and returns "owner/repo".
+ * Only returns results for github.com hosts — GHE URLs return null.
+ * Use parseGitRemote() for GHE support.
+ * Also accepts plain "owner/repo" strings for backward compatibility.
+ */
+export function parseGitHubRepository(input: string): string | null {
+  const trimmed = input.trim()
+
+  // Try parsing as a full remote URL first.
+  // Only return results for github.com hosts — existing callers (VS Code extension,
+  // bridge) assume this function is GitHub.com-specific. Use parseGitRemote() directly
+  // for GHE support.
+  const parsed = parseGitRemote(trimmed)
+  if (parsed) {
+    if (parsed.host !== 'github.com') return null
+    return `${parsed.owner}/${parsed.name}`
+  }
+
+  // If no URL pattern matched, check if it's already in owner/repo format
+  if (
+    !trimmed.includes('://') &&
+    !trimmed.includes('@') &&
+    trimmed.includes('/')
+  ) {
+    const parts = trimmed.split('/')
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      // Remove .git extension if present
+      const repo = parts[1].replace(/\.git$/, '')
+      return `${parts[0]}/${repo}`
+    }
+  }
+
+  logForDebugging(`Could not parse repository from: ${trimmed}`)
+  return null
+}
+
+/**
+ * Checks whether a hostname looks like a real domain name rather than an
+ * SSH config alias. A simple dot-check is not enough because aliases like
+ * "github.com-work" still contain a dot. We additionally require that the
+ * last segment (the TLD) is purely alphabetic — real TLDs (com, org, io, net)
+ * never contain hyphens or digits.
+ */
+function looksLikeRealHostname(host: string): boolean {
+  if (!host.includes('.')) return false
+  const lastSegment = host.split('.').pop()
+  if (!lastSegment) return false
+  // Real TLDs are purely alphabetic (e.g., "com", "org", "io").
+  // SSH aliases like "github.com-work" have a last segment "com-work" which
+  // contains a hyphen.
+  return /^[a-zA-Z]+$/.test(lastSegment)
+}