@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/lib/platform/github-client.ts

@@ -0,0 +1,146 @@
+import process from 'node:process';
+import spawn from 'cross-spawn';
+
+import semver from 'semver';
+
+import type { PlatformError } from './types.ts';
+
+type RunResult = { status: number | null; stdout: string; stderr: string; error?: Error };
+type RunOptions = { cwd?: string; input?: string };
+type Runner = (args: string[], options: RunOptions) => RunResult;
+type RequestOptions = RunOptions & { method?: 'GET' | 'PATCH' | 'POST' | 'DELETE' };
+type ClientResult<T> = { ok: true; value: T } | { ok: false; error: PlatformError };
+
+type GitHubClient = {
+  version(options?: RunOptions): ClientResult<string>;
+  json<T = unknown>(args: string[], options?: RequestOptions): ClientResult<T>;
+  text(args: string[], options?: RequestOptions): ClientResult<string>;
+};
+
+type ClientOptions = {
+  runner?: Runner;
+  retryDelaysMs?: number[];
+  sleep?: (delayMs: number) => void;
+};
+
+const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+
+function defaultRunner(args: string[], options: RunOptions): RunResult {
+  const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
+  let prefix: string[] = [];
+  try {
+    prefix = JSON.parse(process.env.AGENT_INFRA_GH_ARGS_JSON || '[]') as string[];
+  } catch {
+    prefix = [];
+  }
+  const result = spawn.sync(command, [...prefix, ...args], {
+    cwd: options.cwd,
+    encoding: 'utf8',
+    env: process.env,
+    input: options.input,
+    shell: false
+  });
+  return {
+    status: result.status,
+    stdout: String(result.stdout || ''),
+    stderr: String(result.stderr || ''),
+    error: result.error
+  };
+}
+
+function retryDelaysFromEnvironment(): number[] {
+  const raw = process.env.AGENT_INFRA_PLATFORM_RETRY_DELAYS_MS;
+  if (!raw) return [3000, 10000];
+  return raw.split(',').map(Number).filter((value) => Number.isFinite(value) && value >= 0);
+}
+
+function defaultSleep(delayMs: number): void {
+  if (delayMs <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
+}
+
+function classifyGitHubFailure(result: RunResult): PlatformError {
+  const detail = `${result.stderr}\n${result.stdout}\n${result.error?.message || ''}`.trim();
+  const lower = detail.toLowerCase();
+  if (/\b401\b|bad credentials|authentication required|not logged into/.test(lower)) {
+    return { code: 'AUTH_REQUIRED', message: detail || 'GitHub authentication is required', retryable: false };
+  }
+  if (/\b429\b|rate limit|secondary rate|\b5\d\d\b|timeout|timed out|econnreset|enotfound|dns|tls|socket|network/.test(lower)) {
+    return { code: 'NETWORK_TRANSIENT', message: detail || 'GitHub request failed temporarily', retryable: true };
+  }
+  if (/\b403\b|resource not accessible|permission denied/.test(lower)) {
+    return { code: 'PERMISSION_DENIED', message: detail || 'GitHub permission denied', retryable: false };
+  }
+  if (/\b404\b/.test(lower)) {
+    return { code: 'RESOURCE_NOT_FOUND', message: detail || 'GitHub resource not found', retryable: false };
+  }
+  if (/\b422\b|validation failed/.test(lower)) {
+    return { code: 'PLATFORM_REQUEST_INVALID', message: detail || 'GitHub rejected the request', retryable: false };
+  }
+  if (result.error && 'code' in result.error && (result.error as NodeJS.ErrnoException).code === 'ENOENT') {
+    return { code: 'PLATFORM_DEPENDENCY_MISSING', message: detail || 'GitHub CLI is unavailable', retryable: false };
+  }
+  return { code: 'PLATFORM_REQUEST_FAILED', message: detail || 'GitHub request failed', retryable: false };
+}
+
+function createGitHubClient(options: ClientOptions = {}): GitHubClient {
+  const runner = options.runner || defaultRunner;
+  const delays = options.retryDelaysMs || retryDelaysFromEnvironment();
+  const sleep = options.sleep || defaultSleep;
+
+  function run(args: string[], request: RequestOptions = {}): ClientResult<string> {
+    const method = request.method || 'GET';
+    const retryableMethod = method === 'GET' || method === 'PATCH';
+    let attempt = 0;
+    while (true) {
+      const result = runner(args, request);
+      if (result.status === 0) return { ok: true, value: result.stdout };
+      const error = classifyGitHubFailure(result);
+      if (!retryableMethod || !error.retryable) return { ok: false, error };
+      if (attempt >= delays.length) {
+        return {
+          ok: false,
+          error: error.code === 'NETWORK_TRANSIENT'
+            ? { ...error, code: 'NETWORK_RETRY_EXHAUSTED', message: `${error.message} (retry exhausted)` }
+            : error
+        };
+      }
+      sleep(delays[attempt]!);
+      attempt += 1;
+    }
+  }
+
+  return {
+    version(request = {}) {
+      const result = runner(['--version'], request);
+      if (result.status !== 0) return { ok: false, error: classifyGitHubFailure(result) };
+      const version = result.stdout.match(/^gh version (\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\s|$)/m)?.[1];
+      if (!version || !semver.valid(version)) {
+        return {
+          ok: false,
+          error: { code: 'GH_CLI_VERSION_INVALID', message: 'GitHub CLI returned an invalid version', retryable: false }
+        };
+      }
+      return { ok: true, value: version };
+    },
+    text(args, request = {}) {
+      const result = run(args, request);
+      return result.ok ? { ok: true, value: result.value.trim() } : result;
+    },
+    json<T>(args: string[], request: RequestOptions = {}): ClientResult<T> {
+      const result = run(args, request);
+      if (!result.ok) return result;
+      try {
+        return { ok: true, value: JSON.parse(result.value || 'null') as T };
+      } catch {
+        return {
+          ok: false,
+          error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub returned invalid JSON', retryable: true }
+        };
+      }
+    }
+  };
+}
+
+export { classifyGitHubFailure, createGitHubClient, MINIMUM_GITHUB_CLI_VERSION };
+export type { ClientResult, GitHubClient, RequestOptions, RunOptions, RunResult, Runner };

package/lib/platform/github-release-notes.ts

@@ -0,0 +1,132 @@
+import type { GitHubClient } from './github-client.ts';
+import { createGitHubClient } from './github-client.ts';
+
+type GitHubActorInput = {
+  name?: string | null;
+  email?: string | null;
+  user?: { login?: string | null } | null;
+};
+
+type ReleaseNoteActor = {
+  name: string;
+  email: string | null;
+  login: string | null;
+  bot: boolean;
+  resolution: 'platform-user' | 'platform-noreply' | 'unresolved';
+};
+
+type GitHubReleaseNoteOptions = { cwd?: string; client?: GitHubClient };
+
+function normalizeGitHubActor(actor: GitHubActorInput): ReleaseNoteActor {
+  const name = String(actor.name || '').trim();
+  const email = actor.email ? String(actor.email).trim() : null;
+  const platformLogin = actor.user?.login?.trim().toLowerCase() || null;
+  const noReplyLogin = email
+    ? /^(?:\d+\+)?([^@]+)@users\.noreply\.github\.com$/i.exec(email)?.[1]?.toLowerCase() || null
+    : null;
+  const login = platformLogin || noReplyLogin;
+  return {
+    name,
+    email,
+    login,
+    bot: Boolean(login?.endsWith('[bot]')),
+    resolution: platformLogin ? 'platform-user' : noReplyLogin ? 'platform-noreply' : 'unresolved'
+  };
+}
+
+function failure(error: { code: string; message: string; retryable: boolean }) {
+  return {
+    status: error.retryable ? 'blocked' as const : 'failed' as const,
+    changed: false,
+    operation: null,
+    url: null,
+    error
+  };
+}
+
+function publishGitHubReleaseNotes(
+  input: { repository: string; tag: string; title: string; notesFile: string; dryRun?: boolean },
+  options: GitHubReleaseNoteOptions = {}
+) {
+  const client = options.client ?? createGitHubClient();
+  const inspected = client.json<{ url?: string }>(
+    ['release', 'view', input.tag, '--repo', input.repository, '--json', 'url'],
+    { cwd: options.cwd }
+  );
+  if (!inspected.ok && inspected.error.code !== 'RESOURCE_NOT_FOUND') return failure(inspected.error);
+  const exists = inspected.ok;
+  const operation = exists ? 'release:update-notes' as const : 'release:create' as const;
+  if (input.dryRun) {
+    return {
+      status: 'planned' as const,
+      changed: false,
+      operation,
+      url: inspected.ok ? inspected.value.url || null : null,
+      error: null
+    };
+  }
+  const args = exists
+    ? ['release', 'edit', input.tag, '--repo', input.repository, '--notes-file', input.notesFile]
+    : ['release', 'create', input.tag, '--repo', input.repository, '--title', input.title, '--notes-file', input.notesFile];
+  const written = client.text(args, { cwd: options.cwd, method: exists ? 'PATCH' : 'POST' });
+  if (!written.ok) return failure(written.error);
+  return {
+    status: 'applied' as const,
+    changed: true,
+    operation,
+    url: written.value || (inspected.ok ? inspected.value.url || null : null),
+    error: null
+  };
+}
+
+function fetchGitHubReleaseNoteData(
+  input: { repository: string; commitOids: string[]; branch: string; historyLimit: number; fromTime: string; toTime: string },
+  options: GitHubReleaseNoteOptions = {}
+) {
+  const client = options.client ?? createGitHubClient();
+  const releases = client.json<Array<{ tagName?: string; isDraft?: boolean; isPrerelease?: boolean }>>(
+    ['release', 'list', '--repo', input.repository, '--limit', String(input.historyLimit + 10), '--json', 'tagName,isDraft,isPrerelease'],
+    { cwd: options.cwd }
+  );
+  if (!releases.ok) return failure(releases.error);
+  const history = [];
+  for (const item of releases.value.filter((entry) => !entry.isDraft && !entry.isPrerelease).slice(0, input.historyLimit)) {
+    const viewed = client.json<{ body?: string; url?: string }>(
+      ['release', 'view', String(item.tagName), '--repo', input.repository, '--json', 'body,url'],
+      { cwd: options.cwd }
+    );
+    if (!viewed.ok) return failure(viewed.error);
+    history.push({ tag: String(item.tagName), body: String(viewed.value.body || ''), url: viewed.value.url || null });
+  }
+  const prs = client.json<Array<Record<string, unknown>>>(
+    ['pr', 'list', '--repo', input.repository, '--state', 'merged', '--base', input.branch, '--limit', '1000', '--json', 'number,title,body,url,mergedAt,labels,author,closingIssuesReferences'],
+    { cwd: options.cwd }
+  );
+  if (!prs.ok) return failure(prs.error);
+  const authors = new Map<string, ReleaseNoteActor[]>();
+  for (const oid of input.commitOids) {
+    const query = `query($owner:String!,$name:String!,$oid:GitObjectID!){repository(owner:$owner,name:$name){object(oid:$oid){... on Commit{authors(first:100){nodes{name email user{login}} pageInfo{hasNextPage}}}}}}`;
+    const [owner, name] = input.repository.split('/');
+    const result = client.json<{
+      data?: { repository?: { object?: { authors?: { nodes?: GitHubActorInput[]; pageInfo?: { hasNextPage?: boolean } } } } };
+    }>([
+      'api', 'graphql', '-f', `query=${query}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `oid=${oid}`
+    ], { cwd: options.cwd });
+    if (!result.ok) return failure(result.error);
+    const connection = result.value.data?.repository?.object?.authors;
+    if (connection?.pageInfo?.hasNextPage) {
+      return failure({ code: 'RELEASE_NOTES_AUTHORS_TRUNCATED', message: `Commit authors exceeded the supported page size for ${oid}`, retryable: false });
+    }
+    authors.set(oid, (connection?.nodes || []).map(normalizeGitHubActor));
+  }
+  const fromTime = Date.parse(input.fromTime);
+  const toTime = Date.parse(input.toTime);
+  const pullRequests = prs.value.filter((item) => {
+    const mergedAt = Date.parse(String(item.mergedAt || ''));
+    return Number.isFinite(mergedAt) && mergedAt > fromTime && mergedAt <= toTime;
+  });
+  return { status: 'no-op' as const, changed: false, history, pullRequests, authors, error: null };
+}
+
+export { fetchGitHubReleaseNoteData, normalizeGitHubActor, publishGitHubReleaseNotes };
+export type { ReleaseNoteActor };