@fitlab-ai/agent-infra 0.9.1 → 0.9.2

package/lib/platform/pull-requests.ts

@@ -1,10 +1,16 @@
 import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 
 import { parseTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { extractSection } from '../task/sections.ts';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.ts';
-import { resolvePlatformContext } from './context.ts';
+import {
+  inspectPlatformChangeRequest,
+  registerPlatformCapabilities
+} from './adapters.ts';
+import type { PlatformChangeRequestSnapshot } from './adapters.ts';
+import { parseGitHubRemote, resolvePlatformContext } from './context.ts';
 import { createGitHubClient } from './github-client.ts';
 import type { GitHubClient } from './github-client.ts';
 import { inspectPlatformIssue } from './issues.ts';
@@ -12,28 +18,13 @@ import { planPullRequestMetadata } from './pull-request-metadata.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
 
-type PullRequestSnapshot = {
-  repository: string;
-  number: number;
-  nodeId: string;
-  url: string;
-  state: 'open' | 'closed';
-  title: string;
-  body: string;
-  draft: boolean;
-  head: { repository: string; ref: string; sha: string };
-  base: { repository: string; ref: string; sha: string };
-  mergedAt: string | null;
-  mergeCommitSha: string | null;
-  labels: string[];
-  assignees: string[];
-  milestone: string | null;
-};
+type PullRequestSnapshot = PlatformChangeRequestSnapshot;
 
 type PullRequestResult = PlatformResult & {
   task: { id: string | null; issueNumber: number | null; prNumber: number | null };
   pullRequest: PullRequestSnapshot | null;
 };
+type InspectionOptions = { cwd?: string; client?: unknown };
 type SharedOptions = { cwd?: string; client?: GitHubClient };
 type CreateOptions = SharedOptions & {
   agent: string;
@@ -126,7 +117,7 @@ function selectPullRequest(remotes: RemotePullRequest[], repository: string, hea
   return { status: matches.length === 0 ? 'missing' : 'ambiguous', pullRequest: null };
 }
 
-function resolvedContext(taskRef: string, options: SharedOptions) {
+function resolvedContext(taskRef: string, options: InspectionOptions) {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return { ok: false as const, output: result('failed', resolved.taskId, null, null, {
     error: { code: resolved.code, message: resolved.message, retryable: false }
@@ -137,7 +128,7 @@ function resolvedContext(taskRef: string, options: SharedOptions) {
   const pr = Number(frontmatter.pr_number);
   const issueNumber = Number.isInteger(issue) && issue > 0 ? issue : null;
   const prNumber = Number.isInteger(pr) && pr > 0 ? pr : null;
-  const client = options.client || createGitHubClient();
+  const client = (options.client as GitHubClient | undefined) || createGitHubClient();
   const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
   const usable = (context.status === 'no-op' || context.status === 'degraded') && context.platform.repository;
   if (!usable) return { ok: false as const, output: result(context.status, resolved.taskId, issueNumber, prNumber, {
@@ -155,6 +146,111 @@ function inspectGitHubPullRequest(client: GitHubClient, repository: string, numb
     : { ok: false as const, error: { code: 'PR_IDENTITY_INVALID', message: 'Remote resource is not a valid pull request', retryable: false } };
 }
 
+function configuredGitRemotes(cwd: string): Array<{ name: string; url: string; repository: string }> {
+  try {
+    return execFileSync('git', ['remote'], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+    }).split(/\r?\n/).filter(Boolean).flatMap((name) => {
+      try {
+        const url = execFileSync('git', ['config', '--get', `remote.${name}.url`], {
+          cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+        }).trim();
+        const repository = parseGitHubRemote(url);
+        return repository ? [{ name, url, repository }] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+function rewriteGitHubRemote(remote: string, repository: string): string | null {
+  const match = remote.trim().match(
+    /^(https?:\/\/github\.com\/|ssh:\/\/(?:git@)?github\.com\/|git@github\.com:)[^/\s]+\/[^/\s]+(?:\.git)?$/i
+  );
+  return match ? `${match[1]}${repository}.git` : null;
+}
+
+function resolveGitHubChangeRequestGitEvidence({
+  cwd,
+  repository,
+  pullRequest
+}: {
+  cwd: string;
+  repository: string;
+  pullRequest: PullRequestSnapshot;
+}) {
+  if (
+    pullRequest.repository !== repository ||
+    pullRequest.base.repository !== repository ||
+    pullRequest.number <= 0
+  ) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: 'Pull request repository identity is inconsistent',
+        retryable: false
+      }
+    };
+  }
+  const reviewedHeadRef = `refs/pull/${pullRequest.number}/head`;
+  const targetHeadRef = `refs/heads/${pullRequest.base.ref}`;
+  const refValid = (ref: string) => {
+    try {
+      execFileSync('git', ['check-ref-format', ref], {
+        cwd, encoding: 'utf8', stdio: ['ignore', 'ignore', 'ignore']
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!refValid(reviewedHeadRef) || !refValid(targetHeadRef)) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: 'Pull request Git refs are invalid',
+        retryable: false
+      }
+    };
+  }
+
+  const remotes = configuredGitRemotes(cwd);
+  const exact = remotes
+    .filter((remote) => remote.repository === repository)
+    .sort((left, right) => Number(right.name === 'origin') - Number(left.name === 'origin') ||
+      left.name.localeCompare(right.name))[0];
+  const origin = remotes.find((remote) => remote.name === 'origin');
+  const remoteUrl = exact?.url || (origin ? rewriteGitHubRemote(origin.url, repository) : null);
+  if (!remoteUrl) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: `No GitHub remote can provide evidence for ${repository}`,
+        retryable: false
+      }
+    };
+  }
+  return {
+    ok: true as const,
+    value: { remoteUrl, reviewedHeadRef, targetHeadRef }
+  };
+}
+
+registerPlatformCapabilities('github', {
+  inspectChangeRequest({ client, repository, number, cwd }) {
+    return inspectGitHubPullRequest((client as GitHubClient | undefined) || createGitHubClient(), repository, number, cwd);
+  },
+  resolveChangeRequestGitEvidence(context) {
+    return resolveGitHubChangeRequestGitEvidence(context);
+  }
+});
+
 function locatePullRequest(base: ReturnType<typeof resolvedContext> & { ok: true }, head: string, target: string) {
   const repository = base.context.platform.repository!;
   const listed = base.client.json<RemotePullRequest[]>([
@@ -171,18 +267,30 @@ function locatePullRequest(base: ReturnType<typeof resolvedContext> & { ok: true
     } };
 }
 
-function inspectPlatformPullRequest(taskRef: string, options: SharedOptions = {}): PullRequestResult {
+function inspectPlatformPullRequest(taskRef: string, options: InspectionOptions = {}): PullRequestResult {
   const base = resolvedContext(taskRef, options);
   if (!base.ok) return base.output;
   if (!base.prNumber) return result('no-op', base.resolved.taskId, base.issueNumber, null, {
     platform: base.context.platform, capabilities: base.context.capabilities,
     error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false }
   });
-  const fetched = inspectGitHubPullRequest(base.client, base.context.platform.repository!, base.prNumber, base.resolved.repoRoot);
-  if (!fetched.ok) return result(fetched.error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
-    platform: base.context.platform, capabilities: base.context.capabilities,
-    resource: { kind: 'pull-request', number: base.prNumber }, error: fetched.error
+  const fetched = inspectPlatformChangeRequest(base.context.platform.type, {
+    cwd: base.resolved.repoRoot,
+    repository: base.context.platform.repository!,
+    number: base.prNumber,
+    client: options.client || base.client
   });
+  if (!fetched.ok || !fetched.value) {
+    const error = fetched.error || {
+      code: 'PR_INSPECTION_INVALID',
+      message: 'Platform adapter returned no change-request snapshot',
+      retryable: false
+    };
+    return result(error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+      platform: base.context.platform, capabilities: base.context.capabilities,
+      resource: { kind: 'pull-request', number: base.prNumber }, error
+    });
+  }
   return result('no-op', base.resolved.taskId, base.issueNumber, base.prNumber, {
     platform: base.context.platform, capabilities: base.context.capabilities,
     resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: fetched.value, error: null
@@ -380,6 +488,7 @@ export {
   inspectGitHubPullRequest,
   inspectPlatformPullRequest,
   normalizePullRequest,
+  resolveGitHubChangeRequestGitEvidence,
   selectPullRequest,
   syncPlatformPullRequest
 };

package/lib/platform/releases.ts

@@ -21,7 +21,7 @@ function inspectPlatformRelease(tag: string, options: ReleaseOptions = {}) {
     return { ...platformResult(result.error.retryable ? 'blocked' : 'failed'), platform: context.platform, release: null, workflows: [], error: result.error };
   }
   const release: ReleaseSnapshot = { tag: String(result.value.tagName || tag), published: !Boolean(result.value.isDraft), draft: Boolean(result.value.isDraft), url: result.value.url ? String(result.value.url) : null };
-  const runs = client.json<unknown[]>(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,headBranch,status,conclusion,url'], { cwd: options.cwd });
+  const runs = client.json<unknown[]>(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,workflowName,displayTitle,event,headBranch,headSha,status,conclusion,createdAt,databaseId,attempt,url'], { cwd: options.cwd });
   return { ...platformResult(runs.ok ? 'no-op' : runs.error.retryable ? 'blocked' : 'degraded'), platform: context.platform, release, workflows: runs.ok ? runs.value : [], error: runs.ok ? null : runs.error };
 }
 

package/lib/platform/verification-required.ts

@@ -2,10 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 
+import { hasPlatformCapability } from "./adapters.ts";
 import { inspectRequiredChecks } from "./pr-checks.ts";
 import { resolvePlatformContext } from "./context.ts";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
-import { loadPostReviewConfig, resolvePostReviewGlobs } from "../task/review-fingerprint.ts";
 
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
@@ -57,10 +57,9 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
     context.gitRoot && inspection.pullRequest?.head
       ? resolveReviewedHeadRelation({
           gitRoot: context.gitRoot,
-          localHead,
+          comparisonHead: localHead,
           lastReviewedCommit: reviewedHead,
-          pullRequest: inspection.pullRequest,
-          pathspecs: context.pathspecs || [":/"]
+          pullRequest: inspection.pullRequest
         })
       : localHead === reviewedHead && localHead === prHead
         ? { status: "strict" }
@@ -87,14 +86,18 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
 export function check({ taskDir }: any, shared: any): any {
   const task = shared.loadTask(taskDir);
   if (!task.ok) return shared.failResult(CHECK_TYPE, task.message);
-  const platform = resolvePlatformContext({ cwd: shared.repoRoot });
-  if (platform.platform.type !== "github") {
-    return shared.passResult(CHECK_TYPE, "Skipped: this code platform does not provide required checks");
-  }
   const prFlow = readPrFlow(shared.repoRoot);
   if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
     return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
   }
+  const platform = resolvePlatformContext({ cwd: shared.repoRoot });
+  if (!hasPlatformCapability(platform.platform.type, "required-checks")) {
+    return shared.blockedResult(
+      CHECK_TYPE,
+      `Platform '${platform.platform.type || "none"}' does not provide required-checks inspection`,
+      "dependency_error"
+    );
+  }
   const localHead = readHead(shared.repoRoot);
   if (!localHead) return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection: null, prFlow }, shared);
   const inspection = inspectRequiredChecks(task.metadata.id, { cwd: shared.repoRoot });
@@ -103,7 +106,6 @@ export function check({ taskDir }: any, shared: any): any {
     localHead,
     inspection,
     prFlow,
-    gitRoot: shared.repoRoot,
-    pathspecs: resolvePostReviewGlobs({}, loadPostReviewConfig(shared.repoRoot))
+    gitRoot: shared.repoRoot
   }, shared);
 }

package/lib/prompt.ts

@@ -88,20 +88,33 @@ async function select(question: string, choices: string[], defaultValue?: string
 
 async function multiSelect(
   question: string,
-  choices: { id: string; label: string }[]
+  choices: { id: string; label: string }[],
+  defaultIds: readonly string[] = choices.map((choice) => choice.id)
 ): Promise<string[]> {
+  const choiceIds = new Set(choices.map((choice) => choice.id));
+  if (defaultIds.some((id) => !choiceIds.has(id))) {
+    throw new Error('Default selection contains an unknown id');
+  }
+  const normalizedDefaults = choices
+    .map((choice) => choice.id)
+    .filter((id) => defaultIds.includes(id));
   process.stdout.write(`  ${question}:\n`);
   const idWidth = Math.max(...choices.map((c) => c.id.length));
   choices.forEach((c, i) => {
     process.stdout.write(`      ${i + 1}) ${c.id.padEnd(idWidth)}  (${c.label})\n`);
   });
-  ask('Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: all]: ');
+  const defaultLabel = normalizedDefaults.length === choices.length
+    ? 'all'
+    : normalizedDefaults.length === 0
+      ? 'none'
+      : normalizedDefaults.join(',');
+  ask(`Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: ${defaultLabel}]: `);
 
   setupInterface();
 
   const line = await nextLine();
   // Strictly distinguish bare Enter (null/empty string) from whitespace input.
-  if (line === null || line === '') return choices.map((c) => c.id);
+  if (line === null || line === '') return normalizedDefaults;
   // Explicit empty selection: "none" means deliberately zero built-in choices.
   if (line.trim().toLowerCase() === 'none') return [];
 

package/lib/release/channels.ts

@@ -20,7 +20,10 @@ async function inspectHomebrewChannel(url: string, version: string, fetcher: Fet
     if (!response.ok) return { status: 'blocked' as const, published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: `formula endpoint returned ${response.status}` } };
     const formula = await response.text();
     const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return { status: 'no-op' as const, published: new RegExp(`(?:version\\s+["']${escaped}["']|/v?${escaped}\\.)`).test(formula), version, error: null };
+    const formulaUrl = /^\s*url\s+["']([^"']+)["']\s*$/m.exec(formula)?.[1] ?? '';
+    const npmTarball = new RegExp(`^https://registry\\.npmjs\\.org/.+/-/[^/]+-${escaped}\\.tgz$`).test(formulaUrl);
+    const bottle = /^\s*bottle do\s*$/m.test(formula);
+    return { status: 'no-op' as const, published: npmTarball && bottle, version, error: null };
   } catch (error) {
     return { status: 'blocked' as const, published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) } };
   }

package/lib/release/workflow.ts

@@ -1,8 +1,8 @@
 type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'complete';
-type ReleaseFacts = { localTag: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
+type ReleaseFacts = { localTag: boolean; localTagAncestor?: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
 
 function deriveReleasePhase(facts: ReleaseFacts): ReleasePhase {
-  if (!facts.localTag) return 'unprepared';
+  if (!facts.localTag && !facts.localTagAncestor) return 'unprepared';
   if (!facts.remoteBranch && !facts.remoteTag) return 'prepared';
   if (!facts.remoteBranch || !facts.remoteTag) return 'partially-published';
   if (facts.githubRelease !== true || facts.npm !== true || facts.homebrew !== true) return 'published';
@@ -17,8 +17,9 @@ function releaseSnapshot(version: string, facts: ReleaseFacts) {
 async function runReleaseAction(input: { version: string; action: 'inspect' | 'prepare' | 'publish' | 'post'; inspect: () => Promise<ReleaseFacts>; prepare?: () => Promise<void>; publish?: () => Promise<void>; post?: () => Promise<void> }) {
   const before = releaseSnapshot(input.version, await input.inspect());
   if (input.action === 'inspect') return { status: 'no-op' as const, changed: false, before, snapshot: before, error: null };
+  if (before.facts.localTagConflict) return { status: 'failed' as const, changed: false, before, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag ${before.tag} is not reachable from HEAD` } };
   const allowed = input.action === 'prepare' ? before.phase === 'unprepared'
-    : input.action === 'publish' ? ['prepared', 'partially-published'].includes(before.phase)
+    : input.action === 'publish' ? before.facts.localTag && ['prepared', 'partially-published'].includes(before.phase)
       : ['published', 'post-pending'].includes(before.phase);
   if (!allowed) return { status: before.phase === 'complete' ? 'no-op' as const : 'failed' as const, changed: false, before, snapshot: before, error: before.phase === 'complete' ? null : { code: 'RELEASE_PHASE_INVALID', message: `Cannot ${input.action} from ${before.phase}` } };
   await input[input.action]?.();

package/lib/remove-dir.ts

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function removeDirRecursive(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+
+  const pending = [dir];
+  const directories: string[] = [];
+  while (pending.length > 0) {
+    const current = pending.pop()!;
+    const stat = fs.lstatSync(current);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      fs.unlinkSync(current);
+      continue;
+    }
+
+    directories.push(current);
+    for (const entry of fs.readdirSync(current)) {
+      pending.push(path.join(current, entry));
+    }
+  }
+
+  for (const directory of directories.reverse()) {
+    fs.rmdirSync(directory);
+  }
+}

package/lib/run/tui.ts

@@ -1,3 +1,6 @@
+import { renderAgentClientInvocation } from '../agent-clients/invocation.ts';
+import { getAgentClientAdapter } from '../agent-clients/registry.ts';
+
 export type TuiName = 'claude' | 'codex' | 'gemini' | 'opencode';
 
 const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
@@ -27,7 +30,12 @@ export function selectTui(
 
 export function renderPrompt(params: { tui: TuiName; skill: string; args: string[] }): string {
   const suffix = [params.skill, ...params.args].join(' ').trim();
-  if (params.tui === 'codex') return `$${suffix}`;
+  if (params.tui === 'codex') {
+    return renderAgentClientInvocation(getAgentClientAdapter('codex').invocation, {
+      skillName: params.skill,
+      args: params.args
+    });
+  }
   if (params.tui === 'gemini') return `/agent-infra:${suffix}`;
   return `/${suffix}`;
 }