neondeck 1.0.0-beta.4

package/src/modules/autopilot/state.ts

@@ -0,0 +1,255 @@
+/* eslint-disable no-unused-vars */
+import { defineTool } from '@flue/runtime';
+import { DatabaseSync } from 'node:sqlite';
+import * as v from 'valibot';
+import { listExecutionApprovals } from '../execution';
+import { flueRunInspectionUrl } from '../runtime';
+import {
+  globalAutopilotPolicy,
+  mergeAutopilotConcurrency,
+  mergeAutopilotLimits,
+  readRepoAutopilotConfig,
+  type AutopilotConcurrencyPolicy,
+  type AutopilotMode,
+  type AutopilotPolicyLimits,
+} from '../autopilot-policy';
+import {
+  ensureRuntimeHome,
+  parseAppConfig,
+  parseRepoRegistry,
+  readRuntimeJson,
+  runtimePaths,
+  type RepoConfig,
+  type RuntimePaths,
+} from '../../runtime-home';
+import { listNotifications, type NotificationLevel } from '../app-state';
+import { listAutopilotAdmissions } from './admissions';
+import { repoFullName } from '../repos';
+import {
+  listPreparedDiffs,
+  type PreparedDiffApprovalRecord,
+  type PreparedDiffRecord,
+  type PreparedDiffStatus,
+} from '../prepared-diffs';
+import { listPrWatchRecords, type PrWatch } from '../watches';
+import {
+  listWorktrees,
+  type WorktreeLifecycleStatus,
+  type WorktreeRecord,
+} from '../worktrees';
+import {
+  autopilotStateSchema,
+  modeLabels,
+  isCheckWorkflow,
+  type AutopilotState,
+} from './state-schemas';
+import {
+  approvalFromExecution,
+  approvalFromPreparedDiff,
+  globalPolicy,
+  isAutopilotApproval,
+  preparedDiffFromRecord,
+  queueItemFromApproval,
+  queueItemFromPreparedDiff,
+  queueItemFromWatch,
+  queueItemFromWorkflow,
+  queueItemFromWorktree,
+  queueSort,
+  repoPolicy,
+  runningCheckFromWorkflow,
+  watchPolicy,
+} from './state-mappers';
+import {
+  readActiveAutopilotRuns,
+  readRecentAutopilotWorkflowEvents,
+  readRecentWorktreeEvents,
+} from './state-store';
+
+export { autopilotStateSchema } from './state-schemas';
+
+export const autopilotStateLookupTool = defineTool({
+  name: 'neondeck_autopilot_state_lookup',
+  description:
+    'Read the Neondeck autopilot operator surface: active PR watches, queue placeholders, worktrees, approvals, running checks, recent activity, and repo/watch policy.',
+  input: v.object({}),
+  output: autopilotStateSchema,
+  async run() {
+    return readAutopilotState();
+  },
+});
+
+export async function readAutopilotState(
+  paths: RuntimePaths = runtimePaths(),
+): Promise<AutopilotState> {
+  await ensureRuntimeHome(paths);
+  const [
+    reposFile,
+    appConfig,
+    watches,
+    worktreeSnapshot,
+    preparedDiffSnapshot,
+    approvals,
+    notifications,
+    admissions,
+  ] = await Promise.all([
+    readRuntimeJson(paths.repos, parseRepoRegistry),
+    readRuntimeJson(paths.config, parseAppConfig),
+    listPrWatchRecords(paths),
+    listWorktrees(paths),
+    listPreparedDiffs({}, paths),
+    listExecutionApprovals(paths, { includeResolved: false }),
+    listNotifications(paths, { includeResolved: true }),
+    listAutopilotAdmissions(paths),
+  ]);
+
+  const repos = reposFile.repos;
+  const repoPolicyMap = new Map(
+    repos.map((repo) => {
+      const policy = repoPolicy(repo, appConfig);
+      return [repo.id, policy] as const;
+    }),
+  );
+  const watchPolicies = watches.map((watch) =>
+    watchPolicy(watch, repoPolicyMap.get(watch.repoId), repos),
+  );
+  const worktrees = worktreeSnapshot.worktrees;
+  const workflowRuns = readActiveAutopilotRuns(paths);
+  const runningChecks = workflowRuns
+    .filter((run) => isCheckWorkflow(run.workflow))
+    .map((run) =>
+      runningCheckFromWorkflow(run, worktrees, appConfig.localApi?.token),
+    );
+  const preparedDiffs = (preparedDiffSnapshot.preparedDiffs ?? []).map(
+    (record) => preparedDiffFromRecord(record, paths),
+  );
+  const failedChecks = preparedDiffs.filter(
+    (diff) => diff.verificationStatus === 'failed',
+  );
+  const pendingApprovals = [
+    ...approvals.approvals
+      .filter(isAutopilotApproval)
+      .map((approval) => approvalFromExecution(approval, worktrees)),
+    ...(preparedDiffSnapshot.approvals ?? []).map((approval) =>
+      approvalFromPreparedDiff(
+        approval,
+        preparedDiffSnapshot.preparedDiffs ?? [],
+      ),
+    ),
+  ];
+  const unreadNotifications = notifications.filter(
+    (notification) =>
+      notification.source === 'autopilot' &&
+      !notification.resolvedAt &&
+      !notification.readAt,
+  );
+  const queue = [
+    ...admissions.map((admission) => ({
+      id: admission.id,
+      source: 'admission' as const,
+      status:
+        admission.state === 'prepared'
+          ? ('prepared' as const)
+          : admission.state === 'blocked' ||
+              admission.state === 'failed' ||
+              admission.state === 'manual-review'
+            ? ('blocked' as const)
+            : admission.state.endsWith('admitted')
+              ? ('running' as const)
+              : ('queued' as const),
+      priority: 'normal' as const,
+      repoId: admission.repoId,
+      repoFullName:
+        (repos.find((repo) => repo.id === admission.repoId)
+          ? repoFullName(repos.find((repo) => repo.id === admission.repoId)!)
+          : undefined) ?? admission.repoId,
+      prNumber: admission.prNumber,
+      title: `${admission.currentWorkflow ?? admission.state} for PR #${admission.prNumber}`,
+      mode: admission.mode,
+      reason: admission.lastError ?? `Durable admission is ${admission.state}.`,
+      nextStep:
+        admission.currentWorkflow ?? 'Await the next autopilot admission.',
+      worktreeId: admission.worktreeId,
+      runId: admission.currentRunId,
+      updatedAt: admission.updatedAt,
+    })),
+    ...watches.map((watch) =>
+      queueItemFromWatch(
+        watch,
+        watchPolicies.find((policy) => policy.watchId === watch.id),
+        worktrees,
+      ),
+    ),
+    ...worktrees
+      .filter((worktree) =>
+        ['busy', 'needs-sync', 'failed'].includes(worktree.lifecycleStatus),
+      )
+      .map((worktree) =>
+        queueItemFromWorktree(worktree, repoPolicyMap.get(worktree.repoId)),
+      ),
+    ...(preparedDiffSnapshot.preparedDiffs ?? []).map((preparedDiff) =>
+      queueItemFromPreparedDiff(
+        preparedDiff,
+        repoPolicyMap.get(preparedDiff.repoId),
+      ),
+    ),
+    ...workflowRuns.map((run) => queueItemFromWorkflow(run, worktrees)),
+    ...pendingApprovals.map(queueItemFromApproval),
+  ]
+    .sort(queueSort)
+    .slice(0, 40);
+  const recentActivity = [
+    ...readRecentAutopilotWorkflowEvents(paths),
+    ...readRecentWorktreeEvents(paths, worktrees),
+    ...notifications
+      .filter((notification) => notification.source === 'autopilot')
+      .map((notification) => ({
+        id: notification.id,
+        type: 'notification' as const,
+        level: notification.level,
+        title: notification.title,
+        message: notification.message,
+        repoId: null,
+        repoFullName: null,
+        prNumber: null,
+        createdAt: notification.createdAt,
+      })),
+  ]
+    .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
+    .slice(0, 20);
+
+  const state = {
+    ok: true,
+    action: 'autopilot_state_read',
+    changed: false,
+    modeLabels,
+    summary: {
+      activeWatches: watches.length,
+      queuedItems: queue.length,
+      preparedDiffs: preparedDiffs.length,
+      pendingApprovals: pendingApprovals.length,
+      runningChecks: runningChecks.length,
+      unreadNotifications: unreadNotifications.length,
+      failedChecks: failedChecks.length,
+      recentActivity: recentActivity.length,
+      placeholderAdapters: [
+        'Durable admission rows are included with watches, worktrees, approvals, and Flue observations.',
+        'Watch-level policy reads repo metadata overrides until durable watch-policy rows land.',
+      ],
+    },
+    queue,
+    policies: {
+      global: globalPolicy(appConfig),
+      repos: repos.map(
+        (repo) => repoPolicyMap.get(repo.id) ?? repoPolicy(repo, appConfig),
+      ),
+      watches: watchPolicies,
+    },
+    preparedDiffs,
+    pendingApprovals,
+    runningChecks,
+    recentActivity,
+    fetchedAt: new Date().toISOString(),
+  } satisfies AutopilotState;
+
+  return v.parse(autopilotStateSchema, state) as AutopilotState;
+}

package/src/modules/autopilot/triage-support.ts

@@ -0,0 +1,234 @@
+/* eslint-disable no-unused-vars */
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { type JsonValue } from '@flue/runtime';
+import * as v from 'valibot';
+import {
+  type GitHubCheckSummary,
+  type GitHubFailingCheckFact,
+  type GitHubPullRequestDetail,
+  type GitHubPullRequestEventState,
+  fetchPullRequestEventState,
+  fetchCheckSummary,
+  fetchFailingCheckFacts,
+  fetchPullRequestDetail,
+} from '../github';
+import {
+  checkAutopilotConcurrency,
+  checkAutopilotPolicy,
+  pathDeniedByAutopilotPolicy,
+  repoAutopilotPolicy,
+  withAutopilotLocalExecutionSlot,
+} from '../autopilot-policy';
+import { addWorkflowSummary, updateWorkflowSummary } from '../app-state';
+import {
+  notifyAutopilotState,
+  recoveryActionsForPreparedDiff,
+} from './notifications';
+import { buildPreparedDiffAuditSummary } from '../autonomous-audit';
+import { runApprovedExecution } from '../execution';
+import {
+  getGitHubPrBranchPermissions,
+  postGitHubPrComment,
+} from '../pr-events';
+import {
+  ensurePreparedDiffForWorktree,
+  markPreparedDiffPushBlocked,
+  markPreparedDiffPushed,
+  readPreparedDiff,
+  readPreparedDiffByWorktree,
+  readPreparedDiffRecord,
+  recordPreparedDiffVerification,
+  type PreparedDiffRecord,
+} from '../prepared-diffs';
+import { readRepoRegistrySnapshot, repoFullName } from '../repos';
+import {
+  gitCurrentSha,
+  gitCommitAll,
+  gitCommitPaths,
+  gitPushHead,
+  gitStatus,
+  type GitCommitResult,
+} from '../../repo-edit/git';
+import {
+  patchRepoFiles,
+  readRepoDiff,
+  readRepoFile,
+  replaceRepoFile,
+} from '../../repo-edit';
+import { parseV4APatch } from '../../repo-edit/patch-parser';
+import { repoRelativePathSchema } from '../../repo-edit/schemas';
+import {
+  type RuntimePaths,
+  parseAppConfig,
+  ensureRuntimeHome,
+  readRuntimeJson,
+  runtimePaths,
+} from '../../runtime-home';
+import {
+  createWorktree,
+  listWorktrees,
+  lockWorktree,
+  recordWorktreePushBlocked,
+  recordWorktreePushSucceeded,
+  readManagedWorktree,
+  readWorktreeStatus,
+  releaseWorktreeLock,
+  syncWorktree,
+  type WorktreeRecord,
+} from '../worktrees';
+import {
+  AutopilotActionResult,
+  AutopilotDependencies,
+  AutopilotTriageClass,
+  autopilotFixtureSchema,
+  autopilotModeSchema,
+  autopilotOutputSchema,
+  checkSummarySchema,
+  commentPrAutofixResultInputSchema,
+  fixPrCiFailureInputSchema,
+  fixPrReviewFeedbackInputSchema,
+  prEventDeltaSchema,
+  prEventSnapshotSchema,
+  prFactsSchema,
+  prReviewEventStateSchema,
+  preparePrWorktreeInputSchema,
+  pushPrAutofixInputSchema,
+  reviewFixReplacementSchema,
+  triagePrEventInputSchema,
+  verifyPrWorktreeInputSchema,
+} from './schemas';
+import { unique } from './utils';
+
+export function repoSummary(
+  repo: Awaited<ReturnType<typeof readRepoRegistrySnapshot>>['repos'][number],
+) {
+  return {
+    id: repo.id,
+    fullName: repoFullName(repo),
+    path: repo.path,
+    defaultBranch: repo.defaultBranch,
+  };
+}
+
+export function prFactsFromDetail(
+  detail: GitHubPullRequestDetail,
+): v.InferOutput<typeof prFactsSchema> {
+  const [owner, name] = detail.repo.split('/');
+  return {
+    number: detail.number,
+    title: detail.title,
+    repo: detail.repo,
+    url: detail.url,
+    state: detail.state,
+    draft: detail.draft,
+    merged: detail.merged,
+    mergeCommitSha: detail.mergeCommitSha,
+    headSha: detail.headSha,
+    headRef: detail.headRef ?? detail.headSha,
+    headOwner: detail.headOwner ?? owner,
+    headName: detail.headName ?? name,
+    baseRef: detail.baseRef,
+    updatedAt: detail.updatedAt,
+    maintainerCanModify: detail.maintainerCanModify ?? false,
+  };
+}
+
+export function classifySignals(
+  current: v.InferOutput<typeof prEventSnapshotSchema> | undefined,
+  deltas: Array<v.InferOutput<typeof prEventDeltaSchema>>,
+) {
+  return {
+    noChange: deltas.length === 0,
+    closed: current?.state === 'closed' || current?.merged === true,
+    draft: current?.draft === true,
+    failingChecks:
+      current?.checkStatus === 'failure' ||
+      deltas.some((delta) => delta.type === 'check-failure'),
+    requestedChanges: deltas.some(
+      (delta) => delta.type === 'requested-changes',
+    ),
+    reviewFeedback: deltas.some((delta) => delta.type === 'review-comment'),
+    mergeBlocked:
+      current?.mergeable === false ||
+      current?.outOfDate === true ||
+      deltas.some(
+        (delta) =>
+          delta.type === 'merge-conflict' ||
+          delta.type === 'branch-out-of-date',
+      ),
+    recoveryOnly:
+      deltas.length > 0 &&
+      deltas.every(
+        (delta) =>
+          delta.type === 'check-recovery' ||
+          delta.type === 'review-thread-resolved' ||
+          delta.type === 'metadata',
+      ),
+    explanatory: deltas.some(
+      (delta) => delta.requiresExplanation || delta.type === 'new-commit',
+    ),
+    actionable: deltas.some((delta) => delta.actionable === true),
+  };
+}
+
+export function classificationFor(
+  mode: v.InferOutput<typeof autopilotModeSchema>,
+  signals: ReturnType<typeof classifySignals>,
+): AutopilotTriageClass {
+  if (signals.noChange) return 'no-op';
+  if (signals.closed || signals.recoveryOnly || signals.draft) {
+    return 'notify-only';
+  }
+  if (signals.mergeBlocked) return 'explain-only';
+  if (
+    signals.failingChecks ||
+    signals.requestedChanges ||
+    signals.reviewFeedback ||
+    signals.actionable
+  ) {
+    return mode;
+  }
+  if (signals.explanatory) return 'explain-only';
+  return 'notify-only';
+}
+
+export function reasonsFor(
+  classification: AutopilotTriageClass,
+  mode: v.InferOutput<typeof autopilotModeSchema>,
+  signals: ReturnType<typeof classifySignals>,
+  deltas: Array<v.InferOutput<typeof prEventDeltaSchema>>,
+) {
+  const reasons: string[] = [];
+  if (classification === 'no-op') {
+    reasons.push('No structured PR deltas were supplied.');
+  }
+  if (signals.closed) reasons.push('PR is closed or merged.');
+  if (signals.draft) reasons.push('Draft PRs are not prepared for autofix.');
+  if (signals.recoveryOnly) {
+    reasons.push('Only recovery or metadata deltas were present.');
+  }
+  if (signals.mergeBlocked) {
+    reasons.push('Merge conflict or out-of-date branch needs explanation.');
+  }
+  if (signals.failingChecks) reasons.push('Failing checks are actionable.');
+  if (signals.requestedChanges)
+    reasons.push('Requested changes are actionable.');
+  if (signals.reviewFeedback) reasons.push('Review feedback is actionable.');
+  if (signals.actionable)
+    reasons.push('At least one delta is marked actionable.');
+  if (
+    classification === 'prepare-only' ||
+    classification === 'autofix-with-approval' ||
+    classification === 'autofix-push-when-safe'
+  ) {
+    reasons.push(`Autopilot mode allows ${mode}.`);
+  }
+  if (reasons.length === 0 && deltas.length > 0) {
+    reasons.push(
+      'Delta should be surfaced but does not justify worktree prep.',
+    );
+  }
+  return reasons;
+}

package/src/modules/autopilot/triage.ts

@@ -0,0 +1,156 @@
+/* eslint-disable no-unused-vars */
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { type JsonValue } from '@flue/runtime';
+import * as v from 'valibot';
+import {
+  type GitHubCheckSummary,
+  type GitHubFailingCheckFact,
+  type GitHubPullRequestDetail,
+  type GitHubPullRequestEventState,
+  fetchPullRequestEventState,
+  fetchCheckSummary,
+  fetchFailingCheckFacts,
+  fetchPullRequestDetail,
+} from '../github';
+import {
+  checkAutopilotConcurrency,
+  checkAutopilotPolicy,
+  pathDeniedByAutopilotPolicy,
+  repoAutopilotPolicy,
+  withAutopilotLocalExecutionSlot,
+} from '../autopilot-policy';
+import { addWorkflowSummary, updateWorkflowSummary } from '../app-state';
+import {
+  notifyAutopilotState,
+  recoveryActionsForPreparedDiff,
+} from './notifications';
+import { buildPreparedDiffAuditSummary } from '../autonomous-audit';
+import { runApprovedExecution } from '../execution';
+import {
+  getGitHubPrBranchPermissions,
+  postGitHubPrComment,
+} from '../pr-events';
+import {
+  ensurePreparedDiffForWorktree,
+  markPreparedDiffPushBlocked,
+  markPreparedDiffPushed,
+  readPreparedDiff,
+  readPreparedDiffByWorktree,
+  readPreparedDiffRecord,
+  recordPreparedDiffVerification,
+  type PreparedDiffRecord,
+} from '../prepared-diffs';
+import { readRepoRegistrySnapshot, repoFullName } from '../repos';
+import {
+  gitCurrentSha,
+  gitCommitAll,
+  gitCommitPaths,
+  gitPushHead,
+  gitStatus,
+  type GitCommitResult,
+} from '../../repo-edit/git';
+import {
+  patchRepoFiles,
+  readRepoDiff,
+  readRepoFile,
+  replaceRepoFile,
+} from '../../repo-edit';
+import { parseV4APatch } from '../../repo-edit/patch-parser';
+import { repoRelativePathSchema } from '../../repo-edit/schemas';
+import {
+  type RuntimePaths,
+  parseAppConfig,
+  ensureRuntimeHome,
+  readRuntimeJson,
+  runtimePaths,
+} from '../../runtime-home';
+import {
+  createWorktree,
+  listWorktrees,
+  lockWorktree,
+  recordWorktreePushBlocked,
+  recordWorktreePushSucceeded,
+  readManagedWorktree,
+  readWorktreeStatus,
+  releaseWorktreeLock,
+  syncWorktree,
+  type WorktreeRecord,
+} from '../worktrees';
+import {
+  AutopilotActionResult,
+  AutopilotDependencies,
+  AutopilotTriageClass,
+  autopilotFixtureSchema,
+  autopilotModeSchema,
+  autopilotOutputSchema,
+  checkSummarySchema,
+  commentPrAutofixResultInputSchema,
+  fixPrCiFailureInputSchema,
+  fixPrReviewFeedbackInputSchema,
+  prEventDeltaSchema,
+  prEventSnapshotSchema,
+  prFactsSchema,
+  prReviewEventStateSchema,
+  preparePrWorktreeInputSchema,
+  pushPrAutofixInputSchema,
+  reviewFixReplacementSchema,
+  triagePrEventInputSchema,
+  verifyPrWorktreeInputSchema,
+} from './schemas';
+import { asJsonValue, parseInput } from './utils';
+import {
+  classifySignals,
+  classificationFor,
+  reasonsFor,
+} from './triage-support';
+
+export async function triagePrEvent(
+  rawInput: unknown,
+): Promise<AutopilotActionResult> {
+  const parsed = parseInput(
+    triagePrEventInputSchema,
+    rawInput,
+    'autopilot_triage_pr_event',
+  );
+  if (!parsed.ok) return parsed.result;
+
+  const input = parsed.input;
+  const deltas = input.deltas ?? [];
+  const mode = input.autopilotMode ?? 'prepare-only';
+  const signals = classifySignals(input.current, deltas);
+  const classification = classificationFor(mode, signals);
+  const shouldPrepareWorktree =
+    classification === 'prepare-only' ||
+    classification === 'autofix-with-approval' ||
+    classification === 'autofix-push-when-safe';
+  const reasons = reasonsFor(classification, mode, signals, deltas);
+
+  return {
+    ok: true,
+    action: 'autopilot_triage_pr_event',
+    changed: classification !== 'no-op',
+    message:
+      classification === 'no-op'
+        ? 'PR event does not require autopilot action.'
+        : `PR event classified as ${classification}.`,
+    data: asJsonValue({
+      classification,
+      autopilotMode: mode,
+      shouldPrepareWorktree,
+      nextWorkflow: shouldPrepareWorktree ? 'prepare_pr_worktree' : null,
+      source: input.source ?? 'api',
+      eventId: input.eventId ?? null,
+      admissionId: input.admissionId ?? null,
+      watchId: input.watchId ?? null,
+      repoId: input.repoId ?? null,
+      repoFullName: input.repoFullName ?? null,
+      prNumber: input.prNumber,
+      reasons,
+      deltas,
+      previous: input.previous ?? null,
+      current: input.current ?? null,
+    }),
+  };
+}