@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/platform/context.js

@@ -1,148 +1,88 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import semver from 'semver';
-import { getPlatformAdapter, registerPlatformAdapter } from './adapters.js';
-import { createGitHubClient, MINIMUM_GITHUB_CLI_VERSION } from './github-client.js';
+import { loadPlatformProvider } from './provider-loader.js';
+import { defaultGitRemote, parseGitHubRemote } from './github-provider.js';
 import { platformResult } from './types.js';
-const CURRENT_USER_QUERY = 'query { viewer { login } }';
-function findRepoRoot(cwd) {
-    try {
-        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-    }
-    catch {
-        return cwd;
-    }
-}
-function parseGitHubRemote(remote) {
-    const trimmed = remote.trim().replace(/\.git$/, '');
-    const match = trimmed.match(/^(?:https?:\/\/github\.com\/|ssh:\/\/(?:git@)?github\.com\/|git@github\.com:)([^/\s]+\/[^/\s]+)$/i);
-    return match?.[1] || null;
-}
-function defaultGitRemote(cwd) {
-    try {
-        return execFileSync('git', ['remote', 'get-url', 'origin'], {
-            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-    }
-    catch {
-        return null;
-    }
+function errorStatus(error) {
+    if (error.retryable || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING')
+        return 'blocked';
+    if (error.code === 'REMOTE_MISSING' || error.code === 'PLATFORM_UNSUPPORTED')
+        return 'no-op';
+    return 'failed';
 }
-function readPlatformType(repoRoot) {
-    try {
-        const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
-        return typeof config?.platform?.type === 'string' ? config.platform.type : null;
-    }
-    catch {
-        return null;
-    }
-}
-function failure(error, repo) {
-    const blocked = error.retryable || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING';
-    return platformResult(blocked ? 'blocked' : 'failed', {
-        platform: { type: 'github', repository: repo, currentUser: null }, error
+function contextError(providerType, error, repository = null) {
+    return platformResult(errorStatus(error), {
+        platform: { type: providerType || null, repository, currentUser: null },
+        error: { code: error.code, message: error.message, retryable: error.retryable }
     });
 }
-function resolveGitHubContext(options) {
-    const { cwd } = options;
-    const platform = 'github';
-    const client = options.client || createGitHubClient();
-    const version = client.version({ cwd });
-    if (!version.ok)
-        return failure(version.error, null);
-    if (!semver.gte(version.value, MINIMUM_GITHUB_CLI_VERSION)) {
-        return failure({
-            code: 'GH_CLI_VERSION_UNSUPPORTED',
-            message: `GitHub CLI ${version.value} is unsupported; install gh >= ${MINIMUM_GITHUB_CLI_VERSION}`,
-            retryable: false
-        }, null);
-    }
-    const remote = (options.gitRemote || defaultGitRemote)(cwd);
-    if (!remote) {
+function contextFromSnapshot(providerType, snapshot) {
+    if (providerType === 'none') {
         return platformResult('no-op', {
-            platform: { type: platform, repository: null, currentUser: null },
-            error: { code: 'REMOTE_MISSING', message: 'Git origin remote is not configured', retryable: false }
-        });
-    }
-    const ownerRepo = parseGitHubRemote(remote);
-    if (!ownerRepo) {
-        const nonGitHub = !/github\.com/i.test(remote);
-        return platformResult(nonGitHub ? 'no-op' : 'failed', {
-            platform: { type: platform, repository: null, currentUser: null },
-            error: {
-                code: nonGitHub ? 'PLATFORM_UNSUPPORTED' : 'REMOTE_INVALID',
-                message: `Unable to parse GitHub owner/repo from '${remote}'`,
-                retryable: false
-            }
-        });
-    }
-    const repository = client.json(['api', `repos/${ownerRepo}`], { cwd });
-    if (!repository.ok)
-        return failure(repository.error, null);
-    const repositoryValue = repository.value;
-    const upstream = repositoryValue?.fork ? repositoryValue.parent?.full_name : repositoryValue?.full_name;
-    if (!upstream) {
-        return platformResult('blocked', {
-            platform: { type: platform, repository: null, currentUser: null },
-            error: { code: 'UPSTREAM_UNRESOLVED', message: 'Unable to resolve the upstream repository', retryable: false }
+            platform: { type: 'none', repository: null, currentUser: null },
+            operations: [{ name: 'resolve', status: 'no-op', reasonCode: 'PLATFORM_DISABLED' }]
         });
     }
-    const user = client.json(['api', 'graphql', '-f', `query=${CURRENT_USER_QUERY}`], { cwd });
-    if (!user.ok)
-        return failure(user.error, upstream);
-    const userValue = user.value;
-    const currentUser = userValue?.data?.viewer?.login || null;
-    const permissions = client.json(['api', `repos/${upstream}`], { cwd });
-    if (!permissions.ok)
-        return failure(permissions.error, upstream);
-    const permissionValue = permissions.value;
-    const values = permissionValue?.permissions || {};
-    const capabilities = {
-        authenticated: Boolean(currentUser),
-        comment: Boolean(currentUser),
-        triage: Boolean(values.triage || values.push || values.admin),
-        push: Boolean(values.push || values.admin),
-        admin: Boolean(values.admin)
-    };
+    const capabilities = snapshot.capabilities;
     const status = Object.values(capabilities).every(Boolean) ? 'no-op' : 'degraded';
+    const repository = snapshot.scope.label || snapshot.scope.id || null;
     return platformResult(status, {
-        changed: false,
-        platform: { type: platform, repository: upstream, currentUser },
+        platform: {
+            type: snapshot.type || providerType,
+            repository,
+            currentUser: snapshot.currentUser?.name || snapshot.currentUser?.id || null
+        },
         resource: { kind: 'repository', number: null },
         capabilities,
         operations: [{ name: 'resolve', status: 'no-op', reasonCode: null }]
     });
 }
-registerPlatformAdapter({
-    type: 'github',
-    resolveContext(options) {
-        return resolveGitHubContext(options);
-    }
-});
-registerPlatformAdapter({
-    type: 'none',
-    resolveContext() {
-        return platformResult('no-op', {
-            platform: { type: 'none', repository: null, currentUser: null },
-            operations: [{ name: 'resolve', status: 'no-op', reasonCode: 'PLATFORM_DISABLED' }]
-        });
-    }
-});
-function resolvePlatformContext(options = {}) {
-    const cwd = path.resolve(options.cwd || process.cwd());
-    const repoRoot = findRepoRoot(cwd);
-    const platform = options.platformType ?? readPlatformType(repoRoot);
-    const adapter = getPlatformAdapter(platform);
-    if (!adapter) {
-        return platformResult('no-op', {
-            platform: { type: platform, repository: null, currentUser: null },
-            error: { code: 'PLATFORM_UNSUPPORTED', message: `Platform '${platform || 'none'}' has no registered adapter`, retryable: false }
-        });
+async function resolvePlatformProviderContext(options = {}) {
+    const workingDirectory = path.resolve(options.cwd || process.cwd());
+    const loaded = await loadPlatformProvider({
+        cwd: workingDirectory,
+        platformType: options.platformType,
+        client: options.client
+    });
+    if (!loaded.ok) {
+        if (!loaded.error.providerType && options.platformType === undefined) {
+            return {
+                ok: false,
+                context: platformResult('no-op', {
+                    platform: { type: null, repository: null, currentUser: null },
+                    error: {
+                        code: 'PLATFORM_UNSUPPORTED',
+                        message: 'No platform provider is configured',
+                        retryable: false
+                    }
+                })
+            };
+        }
+        return { ok: false, context: contextError(loaded.error.providerType || options.platformType || '', loaded.error) };
     }
-    return adapter.resolveContext({ cwd, gitRemote: options.gitRemote, client: options.client });
+    const gitRemote = options.gitRemote ? options.gitRemote(workingDirectory) : null;
+    const resolved = await loaded.value.provider.context.resolve({
+        repositoryRoot: loaded.value.repositoryRoot,
+        workingDirectory,
+        scopeId: loaded.value.repositoryRoot,
+        gitRemote
+    });
+    if (!resolved.ok)
+        return {
+            ok: false,
+            context: contextError(loaded.value.providerType, resolved.error)
+        };
+    return {
+        ok: true,
+        value: {
+            ...loaded.value,
+            snapshot: resolved.value,
+            context: contextFromSnapshot(loaded.value.providerType, resolved.value)
+        }
+    };
+}
+async function resolvePlatformContext(options = {}) {
+    const resolved = await resolvePlatformProviderContext(options);
+    return resolved.ok ? resolved.value.context : resolved.context;
 }
-export { parseGitHubRemote, resolvePlatformContext };
+export { defaultGitRemote, parseGitHubRemote, resolvePlatformContext, resolvePlatformProviderContext };
 //# sourceMappingURL=context.js.map

package/dist/lib/platform/github-client.js

@@ -125,7 +125,7 @@ function createGitHubClient(options = {}) {
     const sleep = options.sleep || defaultSleep;
     function run(args, request = {}) {
         const method = request.method || 'GET';
-        const retryableMethod = method === 'GET' || method === 'PATCH';
+        const retryableMethod = method === 'GET' || method === 'PATCH' || method === 'PUT';
         let attempt = 0;
         while (true) {
             const result = runner(args, request);