neondeck 1.0.0-beta.4

package/src/modules/pr-events/target.ts

@@ -0,0 +1,222 @@
+/* eslint-disable no-unused-vars */
+import { defineAction, defineTool, type JsonValue } from '@flue/runtime';
+import { DatabaseSync } from 'node:sqlite';
+import * as v from 'valibot';
+import {
+  fetchPullRequestEventState,
+  postPullRequestComment,
+  type GitHubPullRequestEventState,
+} from '../github';
+import { readRepoRegistrySnapshot, repoFullName } from '../repos';
+import {
+  type RuntimePaths,
+  ensureRuntimeHome,
+  runtimePaths,
+} from '../../runtime-home';
+import {
+  listPrWatchRecords,
+  parseWatchPrReference,
+  type PrWatch,
+} from '../watches';
+import {
+  prEventTargetInputSchema,
+  type PrEventActionResult,
+  type PrEventStateDependencies,
+  type PullRequestTarget,
+} from './schemas';
+import { errorMessage, failResult } from './utils';
+
+export async function fetchEventState(
+  action: string,
+  input: v.InferInput<typeof prEventTargetInputSchema>,
+  paths: RuntimePaths,
+  dependencies: PrEventStateDependencies,
+): Promise<
+  | {
+      ok: true;
+      target: PullRequestTarget;
+      state: GitHubPullRequestEventState;
+    }
+  | { ok: false; result: PrEventActionResult }
+> {
+  await ensureRuntimeHome(paths);
+  const parsed = v.safeParse(prEventTargetInputSchema, input);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      result: failResult(action, 'Invalid PR event state input.', {
+        errors: [v.summarize(parsed.issues)],
+      }),
+    };
+  }
+
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    return {
+      ok: false,
+      result: failResult(action, 'GITHUB_TOKEN is not configured.', {
+        requires: ['GITHUB_TOKEN'],
+      }),
+    };
+  }
+
+  const target = await resolvePullRequestTarget(parsed.output, paths, action);
+  if (!target.ok) return target;
+
+  try {
+    const fetcher =
+      dependencies.fetchPullRequestEventState ?? fetchPullRequestEventState;
+    return {
+      ok: true,
+      target: target.target,
+      state: await fetcher({
+        token,
+        owner: target.target.owner,
+        repo: target.target.repo,
+        number: target.target.number,
+      }),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      result: failResult(action, 'Could not fetch GitHub PR event state.', {
+        errors: [errorMessage(error)],
+      }),
+    };
+  }
+}
+
+export async function resolvePullRequestTarget(
+  input: v.InferOutput<typeof prEventTargetInputSchema>,
+  paths: RuntimePaths,
+  action: string,
+): Promise<
+  | { ok: true; target: PullRequestTarget }
+  | { ok: false; result: PrEventActionResult }
+> {
+  const watches = await listPrWatchRecords(paths);
+  if (input.watchId) {
+    const watch = watches.find((item) => item.id === input.watchId);
+    if (!watch) {
+      return {
+        ok: false,
+        result: failResult(action, `PR watch "${input.watchId}" not found.`, {
+          requires: ['watchId'],
+        }),
+      };
+    }
+
+    return { ok: true, target: targetFromWatch(watch) };
+  }
+
+  if (input.ref) {
+    const registry = await readRepoRegistrySnapshot(paths);
+    const parsed = parseWatchPrReference(input.ref, registry);
+    if (!parsed.ok) {
+      return {
+        ok: false,
+        result: {
+          ok: false,
+          action,
+          changed: false,
+          message: parsed.result.message,
+          requires: parsed.result.requires,
+          errors: parsed.result.errors,
+        },
+      };
+    }
+    const watch = watches.find((item) => item.id === parsed.reference.id);
+    return {
+      ok: true,
+      target: {
+        repoFullName: parsed.reference.repoFullName,
+        owner: parsed.reference.githubOwner,
+        repo: parsed.reference.githubName,
+        number: parsed.reference.prNumber,
+        ...(watch ? { watch } : {}),
+      },
+    };
+  }
+
+  if (!input.repo || !input.prNumber) {
+    return {
+      ok: false,
+      result: failResult(
+        action,
+        'A watchId, ref, or repo plus prNumber is required.',
+        { requires: ['watchId', 'ref', 'repo', 'prNumber'] },
+      ),
+    };
+  }
+
+  const registry = await readRepoRegistrySnapshot(paths);
+  const repo = registry.repos.find(
+    (item) =>
+      item.id === input.repo ||
+      item.github.name === input.repo ||
+      repoFullName(item).toLowerCase() === input.repo?.toLowerCase(),
+  );
+  if (repo) {
+    const fullName = repoFullName(repo);
+    const watch = watches.find(
+      (item) =>
+        item.repoFullName.toLowerCase() === fullName.toLowerCase() &&
+        item.prNumber === input.prNumber,
+    );
+    return {
+      ok: true,
+      target: {
+        repoFullName: fullName,
+        owner: repo.github.owner,
+        repo: repo.github.name,
+        number: input.prNumber,
+        ...(watch ? { watch } : {}),
+      },
+    };
+  }
+
+  const match = input.repo.match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match) {
+    return {
+      ok: false,
+      result: failResult(
+        action,
+        `Repository "${input.repo}" is not configured.`,
+        {
+          requires: ['repo'],
+        },
+      ),
+    };
+  }
+
+  return {
+    ok: true,
+    target: {
+      repoFullName: `${match[1]}/${match[2]}`,
+      owner: match[1],
+      repo: match[2],
+      number: input.prNumber,
+    },
+  };
+}
+
+export function targetFromWatch(watch: PrWatch): PullRequestTarget {
+  return {
+    repoFullName: watch.repoFullName,
+    owner: watch.githubOwner,
+    repo: watch.githubName,
+    number: watch.prNumber,
+    watch,
+  };
+}
+
+export async function isConfiguredRepoTarget(
+  target: PullRequestTarget,
+  paths: RuntimePaths,
+) {
+  const registry = await readRepoRegistrySnapshot(paths);
+  return registry.repos.some(
+    (repo) =>
+      repoFullName(repo).toLowerCase() === target.repoFullName.toLowerCase(),
+  );
+}

package/src/modules/pr-events/utils.ts

@@ -0,0 +1,85 @@
+/* eslint-disable no-unused-vars */
+import { defineAction, defineTool, type JsonValue } from '@flue/runtime';
+import { DatabaseSync } from 'node:sqlite';
+import * as v from 'valibot';
+import {
+  fetchPullRequestEventState,
+  postPullRequestComment,
+  type GitHubPullRequestEventState,
+} from '../github';
+import { readRepoRegistrySnapshot, repoFullName } from '../repos';
+import {
+  type RuntimePaths,
+  ensureRuntimeHome,
+  runtimePaths,
+} from '../../runtime-home';
+import {
+  listPrWatchRecords,
+  parseWatchPrReference,
+  type PrWatch,
+} from '../watches';
+import { type PrEventActionResult, type PullRequestTarget } from './schemas';
+
+export function eventTargetJson(target: PullRequestTarget): JsonValue {
+  return {
+    repoFullName: target.repoFullName,
+    owner: target.owner,
+    repo: target.repo,
+    number: target.number,
+    watchId: target.watch?.id ?? null,
+  };
+}
+
+export function okResult(
+  action: string,
+  changed: boolean,
+  message: string,
+  data: JsonValue,
+): PrEventActionResult {
+  return {
+    ok: true,
+    action,
+    changed,
+    message,
+    data,
+  };
+}
+
+export function failResult(
+  action: string,
+  message: string,
+  details: Pick<PrEventActionResult, 'errors' | 'requires'> = {},
+): PrEventActionResult {
+  return {
+    ok: false,
+    action,
+    changed: false,
+    message,
+    ...(details.requires ? { requires: details.requires } : {}),
+    ...(details.errors ? { errors: details.errors } : {}),
+  };
+}
+
+export function maxString(values: Array<string | null | undefined>) {
+  const filtered = values.filter((value): value is string => Boolean(value));
+  if (filtered.length === 0) return null;
+  return filtered.sort((a, b) => b.localeCompare(a))[0];
+}
+
+export function stableJson(value: unknown) {
+  return JSON.stringify(value);
+}
+
+export function isFailingConclusion(value: string | null) {
+  return [
+    'failure',
+    'cancelled',
+    'timed_out',
+    'action_required',
+    'startup_failure',
+  ].includes(value ?? '');
+}
+
+export function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/modules/pr-events/watermarks.ts

@@ -0,0 +1,308 @@
+/* eslint-disable no-unused-vars */
+import { defineAction, defineTool, type JsonValue } from '@flue/runtime';
+import { DatabaseSync } from 'node:sqlite';
+import * as v from 'valibot';
+import {
+  fetchPullRequestEventState,
+  postPullRequestComment,
+  type GitHubPullRequestEventState,
+} from '../github';
+import { readRepoRegistrySnapshot, repoFullName } from '../repos';
+import {
+  type RuntimePaths,
+  ensureRuntimeHome,
+  runtimePaths,
+} from '../../runtime-home';
+import {
+  listPrWatchRecords,
+  parseWatchPrReference,
+  type PrWatch,
+} from '../watches';
+import {
+  watermarkCategories,
+  type PrWatchEventWatermarkCategory,
+  type PrWatchEventWatermarkRecord,
+} from './schemas';
+import { isFailingConclusion, maxString } from './utils';
+
+export function watermarksFromEventState(
+  watchId: string,
+  state: GitHubPullRequestEventState,
+) {
+  const latestCommit = maxString(
+    state.commits.map((commit) => commit.committedAt),
+  );
+  const latestThreadComment = maxString(
+    state.reviewThreads.flatMap((thread) =>
+      thread.comments.map((comment) => comment.updatedAt),
+    ),
+  );
+  const latestRequestedChanges = maxString(
+    state.requestedChangesReviews.map((review) => review.submittedAt),
+  );
+  const latestSuiteUpdate = maxString(
+    state.checkSuites.map((suite) => suite.updatedAt),
+  );
+  const latestRunUpdate = maxString(
+    state.checkRuns.map((run) => run.completedAt ?? run.startedAt),
+  );
+  const requestedChangesReviews = state.requestedChangesReviews
+    .map((review) => ({
+      id: review.id,
+      authorLogin: review.authorLogin,
+      commitId: review.commitId,
+      submittedAt: review.submittedAt,
+    }))
+    .sort((a, b) => a.id - b.id);
+  const latestRequestedChangeStates =
+    state.requestedChangesState.latestByReviewer
+      .map((review) => ({
+        id: review.id,
+        state: review.state,
+        authorLogin: review.authorLogin,
+        commitId: review.commitId,
+        submittedAt: review.submittedAt,
+      }))
+      .sort((a, b) =>
+        String(a.authorLogin ?? a.id).localeCompare(
+          String(b.authorLogin ?? b.id),
+        ),
+      );
+  const requestedChangeHistory = state.requestedChangesState.history
+    .map((review) => ({
+      id: review.id,
+      state: review.state,
+      authorLogin: review.authorLogin,
+      commitId: review.commitId,
+      submittedAt: review.submittedAt,
+    }))
+    .sort((a, b) => a.id - b.id);
+  const reviewThreads = state.reviewThreads
+    .map((thread) => ({
+      id: thread.id,
+      isResolved: thread.isResolved,
+      isOutdated: thread.isOutdated,
+      path: thread.path,
+      line: thread.line,
+      commentIds: thread.comments
+        .map((comment) => comment.databaseId ?? comment.id)
+        .sort((a, b) => String(a).localeCompare(String(b))),
+      latestCommentUpdatedAt: maxString(
+        thread.comments.map((comment) => comment.updatedAt),
+      ),
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+  const checkSuites = state.checkSuites
+    .map((suite) => ({
+      id: suite.id,
+      headSha: suite.headSha,
+      status: suite.status,
+      conclusion: suite.conclusion,
+      appSlug: suite.appSlug,
+      updatedAt: suite.updatedAt,
+    }))
+    .sort((a, b) => a.id - b.id);
+  const checkRuns = state.checkRuns
+    .map((run) => ({
+      id: run.id,
+      name: run.name,
+      headSha: run.headSha,
+      status: run.status,
+      conclusion: run.conclusion,
+      completedAt: run.completedAt,
+    }))
+    .sort((a, b) => a.id - b.id);
+
+  return [
+    categoryWatermark(watchId, 'commits', latestCommit, {
+      headSha: state.headSha,
+      total: state.commits.length,
+      truncated: state.commitsTruncated ?? false,
+      shas: state.commits.map((commit) => commit.sha).sort(),
+      latestCommittedAt: latestCommit,
+    }),
+    categoryWatermark(watchId, 'review_threads', latestThreadComment, {
+      total: state.reviewThreads.length,
+      truncated: state.reviewThreadsTruncated ?? false,
+      unresolvedThreadIds: reviewThreads
+        .filter((thread) => !thread.isResolved)
+        .map((thread) => thread.id),
+      resolvedThreadIds: reviewThreads
+        .filter((thread) => thread.isResolved)
+        .map((thread) => thread.id),
+      outdatedThreadIds: reviewThreads
+        .filter((thread) => thread.isOutdated)
+        .map((thread) => thread.id),
+      latestCommentUpdatedAt: latestThreadComment,
+      threads: reviewThreads,
+    }),
+    categoryWatermark(
+      watchId,
+      'requested_changes_reviews',
+      latestRequestedChanges,
+      {
+        total: requestedChangesReviews.length,
+        truncated: state.reviewsTruncated ?? false,
+        reviewIds: requestedChangesReviews.map((review) => review.id),
+        latestSubmittedAt: latestRequestedChanges,
+        reviews: requestedChangesReviews,
+        latestByReviewer: latestRequestedChangeStates,
+        history: requestedChangeHistory,
+      },
+    ),
+    categoryWatermark(watchId, 'check_suites', latestSuiteUpdate, {
+      total: checkSuites.length,
+      truncated: state.checkSuitesTruncated ?? false,
+      suiteIds: checkSuites.map((suite) => suite.id),
+      failingSuiteIds: checkSuites
+        .filter((suite) => isFailingConclusion(suite.conclusion))
+        .map((suite) => suite.id),
+      pendingSuiteIds: checkSuites
+        .filter((suite) => suite.status !== 'completed')
+        .map((suite) => suite.id),
+      suites: checkSuites,
+    }),
+    categoryWatermark(watchId, 'check_runs', latestRunUpdate, {
+      total: checkRuns.length,
+      truncated: state.checkRunsTruncated ?? false,
+      runIds: checkRuns.map((run) => run.id),
+      failingRunIds: checkRuns
+        .filter((run) => isFailingConclusion(run.conclusion))
+        .map((run) => run.id),
+      pendingRunIds: checkRuns
+        .filter((run) => run.status !== 'completed')
+        .map((run) => run.id),
+      runs: checkRuns,
+    }),
+    categoryWatermark(watchId, 'mergeability', state.fetchedAt, {
+      state: state.state,
+      draft: state.draft,
+      merged: state.merged,
+      mergeable: state.mergeable,
+      mergeableState: state.mergeableState,
+      mergeCommitSha: state.mergeCommitSha,
+      headSha: state.headSha,
+      baseSha: state.baseSha,
+    }),
+    categoryWatermark(watchId, 'out_of_date_branch', state.fetchedAt, {
+      isOutOfDate: state.isOutOfDate,
+      mergeableState: state.mergeableState,
+      headSha: state.headSha,
+      baseSha: state.baseSha,
+      baseRef: state.baseRef,
+    }),
+  ];
+}
+
+export function categoryWatermark(
+  watchId: string,
+  category: PrWatchEventWatermarkCategory,
+  sourceUpdatedAt: string | null,
+  value: JsonValue,
+) {
+  return { watchId, category, sourceUpdatedAt, value };
+}
+
+export function readWatermarks(
+  paths: RuntimePaths,
+  watchId?: string,
+): PrWatchEventWatermarkRecord[] {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    const query = watchId
+      ? `
+        SELECT *
+        FROM pr_watch_event_watermarks
+        WHERE watch_id = ?
+        ORDER BY category ASC;
+      `
+      : `
+        SELECT *
+        FROM pr_watch_event_watermarks
+        ORDER BY updated_at DESC, watch_id ASC, category ASC;
+      `;
+    return (
+      watchId
+        ? database.prepare(query).all(watchId)
+        : database.prepare(query).all()
+    ).map(readWatermarkRow);
+  } finally {
+    database.close();
+  }
+}
+
+export function upsertWatermarks(
+  paths: RuntimePaths,
+  watchId: string,
+  watermarks: ReturnType<typeof watermarksFromEventState>,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  const now = new Date().toISOString();
+
+  try {
+    database.exec('BEGIN;');
+    try {
+      for (const watermark of watermarks) {
+        database
+          .prepare(
+            `
+            INSERT INTO pr_watch_event_watermarks (
+              watch_id,
+              category,
+              watermark_json,
+              source_updated_at,
+              checked_at,
+              created_at,
+              updated_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(watch_id, category) DO UPDATE SET
+              watermark_json = excluded.watermark_json,
+              source_updated_at = excluded.source_updated_at,
+              checked_at = excluded.checked_at,
+              updated_at = excluded.updated_at;
+          `,
+          )
+          .run(
+            watchId,
+            watermark.category,
+            JSON.stringify(watermark.value),
+            watermark.sourceUpdatedAt,
+            now,
+            now,
+            now,
+          );
+      }
+      database.exec('COMMIT;');
+    } catch (error) {
+      database.exec('ROLLBACK;');
+      throw error;
+    }
+  } finally {
+    database.close();
+  }
+}
+
+export function readWatermarkRow(row: unknown): PrWatchEventWatermarkRecord {
+  const record = row as Record<string, unknown>;
+  const category = String(record.category);
+  return {
+    watchId: String(record.watch_id),
+    category: watermarkCategories.includes(
+      category as PrWatchEventWatermarkCategory,
+    )
+      ? (category as PrWatchEventWatermarkCategory)
+      : 'commits',
+    watermark:
+      typeof record.watermark_json === 'string'
+        ? (JSON.parse(record.watermark_json) as JsonValue)
+        : null,
+    sourceUpdatedAt:
+      typeof record.source_updated_at === 'string'
+        ? record.source_updated_at
+        : null,
+    checkedAt: String(record.checked_at),
+    createdAt: String(record.created_at),
+    updatedAt: String(record.updated_at),
+  };
+}