holo-codex 0.1.0

package/plugins/autonomous-pr-loop/core/autonomy-policy.ts

@@ -0,0 +1,206 @@
+import type {
+  AgentLoopCiCheck,
+  AgentLoopConfig,
+  AgentLoopDecision,
+  AgentLoopGate,
+  AgentLoopReviewComment,
+  AgentLoopRunCheck
+} from "./types.js";
+
+export interface AutonomyPosture {
+  autonomyMode: AgentLoopConfig["autonomyMode"];
+  mergeMode: AgentLoopConfig["mergeMode"];
+  notifyMode: AgentLoopConfig["notifyMode"];
+  reviewHandling: AgentLoopConfig["reviewHandling"];
+  summary: string;
+  notifyWhen: string[];
+  requiresConfirmation: string[];
+  allowConditionalMerge: boolean;
+}
+
+export interface MergeReadiness {
+  state: "manual" | "disabled" | "ready" | "missing_evidence" | "confirmation_required";
+  ready: boolean;
+  missingConditions: string[];
+  evidence: string[];
+  carryoverRecords: string[];
+}
+
+export interface MergeReadinessInput {
+  config: AgentLoopConfig;
+  ci: AgentLoopCiCheck[];
+  reviewComments: AgentLoopReviewComment[];
+  gates: AgentLoopGate[];
+  decisions: AgentLoopDecision[];
+  runChecks: AgentLoopRunCheck[];
+}
+
+/** Explain the repository's current Human On Loop autonomy posture. */
+export function describeAutonomyPosture(config: AgentLoopConfig): AutonomyPosture {
+  return {
+    autonomyMode: config.autonomyMode,
+    mergeMode: config.mergeMode,
+    notifyMode: config.notifyMode,
+    reviewHandling: config.reviewHandling,
+    summary: postureSummary(config),
+    notifyWhen: notifyRules(config),
+    requiresConfirmation: confirmationRules(config),
+    allowConditionalMerge: config.mergeMode === "conditional"
+  };
+}
+
+/** Evaluate whether policy evidence is sufficient for conditional merge. */
+export function evaluateMergeReadiness(input: MergeReadinessInput): MergeReadiness {
+  const missing: string[] = [];
+  const evidence: string[] = [];
+  const carryoverRecords = input.decisions
+    .filter((decision) => decision.kind.includes("carryover") || decision.kind.includes("follow_up"))
+    .map((decision) => decision.message);
+
+  if (input.config.mergeMode === "disabled") {
+    return baseReadiness("disabled", false, ["merge mode disabled"], evidence, carryoverRecords);
+  }
+  if (input.config.mergeMode === "manual") {
+    return baseReadiness("manual", false, ["manual merge mode"], evidence, carryoverRecords);
+  }
+
+  const requiredChecks = new Set(input.config.requiredChecks);
+  if (requiredChecks.size === 0) {
+    if (input.ci.length === 0) {
+      missing.push("CI checks observed or required checks configured");
+    } else {
+      for (const check of input.ci) {
+        if (!ciCheckGreen(check)) {
+          missing.push(`observed check green: ${check.name}`);
+        } else {
+          evidence.push(`observed check green: ${check.name}`);
+        }
+      }
+    }
+  } else {
+    for (const checkName of requiredChecks) {
+      const latest = input.ci.find((check) => check.name === checkName);
+      if (!latest || !ciCheckGreen(latest)) {
+        missing.push(`required check green: ${checkName}`);
+      } else {
+        evidence.push(`check green: ${checkName}`);
+      }
+    }
+  }
+
+  const openActionable = input.reviewComments.filter((comment) =>
+    comment.actionable && !comment.isResolved && !comment.isOutdated && comment.status === "open"
+  );
+  if (openActionable.length > 0) {
+    missing.push("no open actionable review comments");
+  } else {
+    evidence.push("review comments clear");
+  }
+
+  if (input.config.requireReviewApproval) {
+    const approved = input.decisions.some((decision) =>
+      decision.kind.includes("review") && decision.kind.includes("approved")
+    );
+    if (!approved) {
+      missing.push("required review approval recorded");
+    } else {
+      evidence.push("review approval recorded");
+    }
+  }
+
+  if (input.gates.some((gate) => gate.status === "open")) {
+    missing.push("no open gates");
+  } else {
+    evidence.push("no open gates");
+  }
+
+  const gitnexusPassed = input.runChecks.some((check) =>
+    check.kind === "gitnexus_detect_changes" && check.status === "passed"
+  );
+  if (input.config.gitnexusRequired && !gitnexusPassed) {
+    missing.push("GitNexus detect_changes passed");
+  } else {
+    evidence.push(input.config.gitnexusRequired ? "GitNexus passed" : "GitNexus not required");
+  }
+
+  const scopePassed = input.runChecks.some((check) => check.kind === "self_check" && check.status === "passed");
+  if (!scopePassed) {
+    missing.push("self check passed");
+  } else {
+    evidence.push("self check passed");
+  }
+
+  const scopeGuardPassed = input.runChecks.some((check) => check.kind === "scope_guard" && check.status === "passed");
+  if (!scopeGuardPassed) {
+    missing.push("scope guard passed");
+  } else {
+    evidence.push("scope guard passed");
+  }
+
+  const protectedPathsPassed = input.runChecks.some((check) => check.kind === "protected_paths" && check.status === "passed");
+  if (!protectedPathsPassed) {
+    missing.push("protected paths clear");
+  } else {
+    evidence.push("protected paths clear");
+  }
+
+  const carryoverChecked = input.runChecks.some((check) =>
+    check.kind === "carryover_recorded" && (check.status === "passed" || check.status === "skipped")
+  );
+  if (input.config.reviewHandling === "fix_scoped_and_carry_forward") {
+    if (!carryoverChecked && carryoverRecords.length === 0) {
+      missing.push("carryover evaluated or recorded");
+    } else {
+      evidence.push(carryoverRecords.length > 0 ? "carryover recorded" : "carryover evaluated");
+    }
+  }
+
+  return baseReadiness(
+    missing.length === 0 ? "ready" : "missing_evidence",
+    missing.length === 0,
+    missing,
+    evidence,
+    carryoverRecords
+  );
+}
+
+function ciCheckGreen(check: AgentLoopCiCheck): boolean {
+  return check.conclusion?.toLowerCase() === "success" && check.status.toLowerCase() === "completed";
+}
+
+function baseReadiness(
+  state: MergeReadiness["state"],
+  ready: boolean,
+  missingConditions: string[],
+  evidence: string[],
+  carryoverRecords: string[]
+): MergeReadiness {
+  return { state, ready, missingConditions, evidence, carryoverRecords };
+}
+
+function postureSummary(config: AgentLoopConfig): string {
+  const autonomy = config.autonomyMode.replaceAll("_", " ");
+  const merge = config.mergeMode === "conditional" ? "conditional merge when evidence passes" : `${config.mergeMode} merge`;
+  return `Agent runs ${autonomy}; ${merge}; notifications are ${config.notifyMode.replaceAll("_", " ")}.`;
+}
+
+function notifyRules(config: AgentLoopConfig): string[] {
+  if (config.notifyMode === "blockers_only") {
+    return ["blocked", "confirmation_required"];
+  }
+  if (config.notifyMode === "all_gates") {
+    return ["all gates", "CI/review attention", "worker failures", "merge completion"];
+  }
+  return ["blocked", "confirmation_required", "high-risk policy changes", "external reviewer or CI failures"];
+}
+
+function confirmationRules(config: AgentLoopConfig): string[] {
+  const rules = ["dangerous policy changes", "protected path changes"];
+  if (config.mergeMode !== "conditional") {
+    rules.push("manual merge decision");
+  }
+  if (config.autonomyMode === "supervised") {
+    rules.push("run progression beyond one step");
+  }
+  return rules;
+}

package/plugins/autonomous-pr-loop/core/ci.ts

@@ -0,0 +1,131 @@
+import type { AgentLoopCiCheck, AgentLoopConfig, AgentLoopGateKind } from "./types.js";
+import { isRecord } from "./config.js";
+
+export type CiState = "green" | "failed" | "pending" | "missing";
+
+export interface CiEvaluation {
+  state: CiState;
+  gate?: AgentLoopGateKind;
+  checks: Array<Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt">>;
+  missingRequiredChecks: string[];
+}
+
+/** Normalize GitHub statusCheckRollup entries and evaluate required checks. */
+export function evaluateCiChecks(config: AgentLoopConfig, rollup: unknown[]): CiEvaluation {
+  const checks = latestByName(rollup.map(normalizeCheck).filter((check) => check.name.length > 0));
+  if (config.requiredChecks.length === 0) {
+    return evaluateObservedChecks(checks);
+  }
+  const byName = new Map(checks.map((check) => [check.name, check]));
+  const missingRequiredChecks = config.requiredChecks.filter((name) => !byName.has(name));
+  if (missingRequiredChecks.length > 0) {
+    return {
+      state: "missing",
+      gate: "ci_required_checks_missing",
+      checks,
+      missingRequiredChecks
+    };
+  }
+  const required = config.requiredChecks.map((name) => byName.get(name)).filter(isDefined);
+  if (required.some((check) => isFailure(check.conclusion))) {
+    return { state: "failed", checks, missingRequiredChecks: [] };
+  }
+  if (required.some((check) => !isSuccess(check.conclusion) || check.status.toLowerCase() !== "completed")) {
+    return { state: "pending", checks, missingRequiredChecks: [] };
+  }
+  return { state: "green", checks, missingRequiredChecks: [] };
+}
+
+function evaluateObservedChecks(
+  checks: Array<Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt">>
+): CiEvaluation {
+  if (checks.length === 0) {
+    return {
+      state: "missing",
+      gate: "ci_required_checks_missing",
+      checks,
+      missingRequiredChecks: []
+    };
+  }
+  if (checks.some((check) => isFailure(check.conclusion))) {
+    return { state: "failed", checks, missingRequiredChecks: [] };
+  }
+  if (checks.some((check) => !isSuccess(check.conclusion) || check.status.toLowerCase() !== "completed")) {
+    return { state: "pending", checks, missingRequiredChecks: [] };
+  }
+  return { state: "green", checks, missingRequiredChecks: [] };
+}
+
+function normalizeCheck(value: unknown): Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt"> {
+  if (!isRecord(value)) {
+    return { name: "", status: "unknown" };
+  }
+  const name = stringValue(value.name) || stringValue(value.context) || stringValue(value.workflowName);
+  const state = stringValue(value.state);
+  return {
+    name,
+    status: stringValue(value.status) || statusFromState(state),
+    ...(stringValue(value.conclusion) || conclusionFromState(state)
+      ? { conclusion: stringValue(value.conclusion) || conclusionFromState(state) }
+      : {}),
+    ...(stringValue(value.url) || stringValue(value.detailsUrl)
+      ? { url: stringValue(value.url) || stringValue(value.detailsUrl) }
+      : {}),
+    ...(stringValue(value.startedAt) ? { startedAt: stringValue(value.startedAt) } : {}),
+    ...(stringValue(value.completedAt) ? { completedAt: stringValue(value.completedAt) } : {})
+  };
+}
+
+function statusFromState(state: string): string {
+  const normalized = state.toLowerCase();
+  if (["success", "failure", "failed", "error", "cancelled", "skipped"].includes(normalized)) {
+    return "COMPLETED";
+  }
+  if (["pending", "queued", "in_progress", "requested", "waiting"].includes(normalized)) {
+    return "IN_PROGRESS";
+  }
+  return "unknown";
+}
+
+function conclusionFromState(state: string): string {
+  const normalized = state.toLowerCase();
+  if (normalized === "success") return "SUCCESS";
+  if (normalized === "failure" || normalized === "failed" || normalized === "error") return "FAILURE";
+  if (normalized === "cancelled") return "CANCELLED";
+  if (normalized === "skipped") return "SKIPPED";
+  return "";
+}
+
+function latestByName(
+  checks: Array<Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt">>
+): Array<Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt">> {
+  const byName = new Map<string, Omit<AgentLoopCiCheck, "id" | "runId" | "prNumber" | "observedAt">>();
+  for (const check of checks) {
+    const previous = byName.get(check.name);
+    if (!previous || timestamp(check) >= timestamp(previous)) {
+      byName.set(check.name, check);
+    }
+  }
+  return [...byName.values()];
+}
+
+function timestamp(check: { completedAt?: string; startedAt?: string }): number {
+  return Date.parse(check.completedAt ?? check.startedAt ?? "") || 0;
+}
+
+function isSuccess(value: string | undefined): boolean {
+  return value?.toLowerCase() === "success";
+}
+
+function isFailure(value: string | undefined): boolean {
+  const normalized = value?.toLowerCase();
+  return normalized === "failure" || normalized === "failed" || normalized === "timed_out";
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function isDefined<T>(value: T | undefined): value is T {
+  return value !== undefined;
+}

package/plugins/autonomous-pr-loop/core/cli-i18n.ts

@@ -0,0 +1,123 @@
+import {
+  DEFAULT_LOCALE,
+  normalizeLocaleSetting,
+  processLocaleCandidates,
+  resolveEffectiveLocale,
+  type EffectiveLocale,
+  type LocaleSetting
+} from "./locale.js";
+
+type CliTextKey =
+  | "approvedGate"
+  | "baseBranch"
+  | "config"
+  | "currentBranch"
+  | "dashboardHelp"
+  | "dashboardStarted"
+  | "doctor"
+  | "gate"
+  | "hooks"
+  | "hooksInstalled"
+  | "initDone"
+  | "initDryRun"
+  | "kind"
+  | "note"
+  | "plansDir"
+  | "recovered"
+  | "repoId"
+  | "runId"
+  | "state"
+  | "status"
+  | "storage"
+  | "url";
+
+const CLI_TEXT: Record<EffectiveLocale, Record<CliTextKey, string>> = {
+  "en-US": {
+    approvedGate: "gate approved",
+    baseBranch: "baseBranch",
+    config: "config",
+    currentBranch: "currentBranch",
+    dashboardHelp: "Starts the local HOLO-Codex dashboard.",
+    dashboardStarted: "dashboard started",
+    doctor: "doctor",
+    gate: "gate",
+    hooks: "hooks",
+    hooksInstalled: "hooks installed",
+    initDone: "init: .agent-loop initialized",
+    initDryRun: "init dry-run: no files written",
+    kind: "kind",
+    note: "note",
+    plansDir: "plansDir",
+    recovered: "recovered",
+    repoId: "repoId",
+    runId: "runId",
+    state: "state",
+    status: "status",
+    storage: "storage",
+    url: "url"
+  },
+  "zh-CN": {
+    approvedGate: "gate 已批准",
+    baseBranch: "基础分支",
+    config: "配置",
+    currentBranch: "当前分支",
+    dashboardHelp: "启动本地 HOLO-Codex dashboard。",
+    dashboardStarted: "dashboard 已启动",
+    doctor: "诊断",
+    gate: "gate",
+    hooks: "hooks",
+    hooksInstalled: "hooks 已安装",
+    initDone: "init: .agent-loop 已初始化",
+    initDryRun: "init dry-run: 未写入文件",
+    kind: "类型",
+    note: "备注",
+    plansDir: "计划目录",
+    recovered: "已恢复",
+    repoId: "repoId",
+    runId: "runId",
+    state: "状态",
+    status: "状态",
+    storage: "存储",
+    url: "url"
+  }
+};
+
+/** Resolve CLI locale from an optional override and repository config setting. */
+export function resolveCliLocale(
+  override: LocaleSetting | undefined,
+  configLocale: LocaleSetting | undefined
+): EffectiveLocale {
+  return resolveEffectiveLocale(override ?? configLocale ?? DEFAULT_LOCALE, processLocaleCandidates());
+}
+
+/** Parse and validate a `--locale` option from raw CLI args. */
+export function parseLocaleOverride(args: string[]): LocaleSetting | undefined {
+  const value = optionValue(args, "--locale");
+  if (value === undefined) {
+    return undefined;
+  }
+  return normalizeLocaleSetting(value);
+}
+
+/** Remove locale option tokens before command-specific parsing. */
+export function stripLocaleArgs(args: string[]): string[] {
+  const next: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--locale") {
+      index += 1;
+      continue;
+    }
+    next.push(args[index]!);
+  }
+  return next;
+}
+
+/** Return display text for CLI human output. */
+export function cliText(locale: EffectiveLocale, key: CliTextKey): string {
+  return CLI_TEXT[locale][key];
+}
+
+function optionValue(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}