@fdcn/sourcefed 0.2.0

package/dist.dts/packages/core/src/types/monitor-event-queue.d.ts

@@ -0,0 +1,18 @@
+import type { MonitorEvent } from "./monitor-event.js";
+import type { MonitorTarget } from "./monitor-target.js";
+import type { MonitorRecord } from "../monitors/types/monitor-record.js";
+export type QueuedMonitorEvent = {
+    id: string;
+    monitorID: string;
+    target: MonitorTarget;
+    event: MonitorEvent;
+    queuedAt: string;
+};
+export interface MonitorEventQueue {
+    enqueue(input: {
+        monitor: MonitorRecord;
+        event: MonitorEvent;
+    }): Promise<QueuedMonitorEvent>;
+    read(target: MonitorTarget): Promise<QueuedMonitorEvent[]>;
+    acknowledge(target: MonitorTarget, eventIDs: string[]): Promise<void>;
+}

package/dist.dts/packages/core/src/types/monitor-event.d.ts

@@ -0,0 +1,10 @@
+export type MonitorEvent = {
+    source: unknown;
+    kind: string;
+    id?: string;
+    at: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+    terminal?: boolean;
+};

package/dist.dts/packages/core/src/types/monitor-options.d.ts

@@ -0,0 +1,7 @@
+import type * as v from "valibot";
+import type { MonitorSource } from "#sourcefed/sources";
+export type MonitorSchema<TSource extends MonitorSource> = v.BaseSchema<unknown, TSource, v.BaseIssue<unknown>>;
+export type MonitorOptions<TSource extends MonitorSource> = {
+    type: TSource["type"];
+    schema: MonitorSchema<TSource>;
+};

package/dist.dts/packages/core/src/types/monitor-store.d.ts

@@ -0,0 +1,6 @@
+import type { MonitorRegistry } from "../monitors/types/monitor-registry.js";
+export interface MonitorStore {
+    load(): Promise<MonitorRegistry>;
+    save(registry: MonitorRegistry): Promise<void>;
+    acquireExclusive?(): Promise<() => Promise<void>>;
+}

package/dist.dts/packages/core/src/types/monitor-target.d.ts

@@ -0,0 +1,4 @@
+export type MonitorTarget = {
+    kind: string;
+    id: string;
+};

package/dist.dts/packages/core/src/types/source-event.d.ts

@@ -0,0 +1,9 @@
+export type SourceEvent = {
+    kind: string;
+    id?: string;
+    at: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+    terminal?: boolean;
+};

package/dist.dts/packages/core/src/types/source-poll-result.d.ts

@@ -0,0 +1,6 @@
+import type { MonitorEvent } from "./monitor-event.js";
+export type SourcePollResult = {
+    cursor: unknown;
+    events: MonitorEvent[];
+    terminal: boolean;
+};

package/dist.dts/packages/core/src/utils/event-to-text.d.ts

@@ -0,0 +1,2 @@
+import type { MonitorEvent } from "#sourcefed/types";
+export declare function eventToText(event: MonitorEvent): string;

package/dist.dts/packages/core/src/utils/to-monitor-event.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorEvent, SourceEvent } from "#sourcefed/types";
+import type { MonitorSource } from "#sourcefed/sources";
+export declare function toMonitorEvent(event: SourceEvent, source: MonitorSource): MonitorEvent;

package/dist.dts/packages/daemon/src/client.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonClient, DaemonClientOptions } from "./types";
+export declare function connectDaemonClient(options: DaemonClientOptions): Promise<DaemonClient>;

package/dist.dts/packages/daemon/src/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/packages/daemon/src/daemon.d.ts

@@ -0,0 +1,36 @@
+import { MonitorRuntime, type MonitorRecord, type MonitorTarget, type QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+import type { DaemonCreateInput, DaemonResult, LogEntryView, MonitorView, SourcefedDaemonOptions } from "./types";
+export declare class SourcefedDaemon {
+    readonly runtime: MonitorRuntime;
+    private readonly store;
+    private readonly queue;
+    private readonly listeners;
+    private readonly observers;
+    private readonly received;
+    private readonly emitChains;
+    private readonly deliveryLog;
+    private releaseExclusive?;
+    private started;
+    constructor(options?: SourcefedDaemonOptions);
+    get service(): import("@fdcn/sourcefed/core").MonitorService;
+    get sourceTypes(): readonly string[];
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    webhook(request: Request): Promise<Response>;
+    createMonitor(target: MonitorTarget, input: DaemonCreateInput): Promise<DaemonResult>;
+    listMonitors(target: MonitorTarget): Promise<DaemonResult>;
+    getMonitor(target: MonitorTarget, id: string): Promise<DaemonResult>;
+    stopMonitor(target: MonitorTarget, id: string): Promise<DaemonResult>;
+    startMonitor(target: MonitorTarget, id: string): Promise<DaemonResult>;
+    removeMonitor(target: MonitorTarget, id: string): Promise<DaemonResult>;
+    readEvents(target: MonitorTarget): Promise<QueuedMonitorEvent[]>;
+    readLogs(target: MonitorTarget): Promise<LogEntryView[]>;
+    acknowledgeEvents(target: MonitorTarget, eventIDs: string[]): Promise<DaemonResult>;
+    subscribe(target: MonitorTarget, onEvents: (events: QueuedMonitorEvent[]) => void): () => void;
+    observe(onEvent: (target: MonitorTarget) => void): () => void;
+    private appendLog;
+    private emit;
+    private deliver;
+}
+export declare function monitorView(monitor: MonitorRecord): MonitorView;
+export declare function logEntryView(queued: QueuedMonitorEvent): LogEntryView;

package/dist.dts/packages/daemon/src/daemon.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/packages/daemon/src/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { SourcefedDaemon } from "./daemon.js";
+export declare function dispatchDaemonRequest(daemon: SourcefedDaemon, method: string, params: Record<string, unknown>): Promise<unknown>;

package/dist.dts/packages/daemon/src/http.d.ts

@@ -0,0 +1,5 @@
+import type { SourcefedDaemon } from "./daemon.js";
+export type DaemonHttpOptions = {
+    token?: string;
+};
+export declare function handleDaemonHttpRequest(daemon: SourcefedDaemon, request: Request, options?: DaemonHttpOptions): Promise<Response>;

package/dist.dts/packages/daemon/src/index.d.ts

@@ -0,0 +1,8 @@
+export { SourcefedDaemon, monitorView } from "./daemon.js";
+export { SOURCE_TYPES } from "./registry.js";
+export { connectDaemonClient } from "./client.js";
+export { defaultDaemonUrl } from "./utils";
+export { dispatchDaemonRequest } from "./dispatch.js";
+export { handleDaemonHttpRequest } from "./http.js";
+export { daemonCommand, daemonEnvironment, DEFAULT_DAEMON_URL, decodeTarget, encodeTarget, serveHttp, spawnLocalDaemon, type HttpServer, type HttpServerOptions } from "./utils";
+export type { DaemonClient, DaemonClientOptions, DaemonCreateInput, DaemonEventFrame, DaemonFrame, DaemonRequest, DaemonResponse, DaemonResult, LogEntryView, MonitorView, SourcefedDaemonOptions, SpawnDaemonResult } from "./types";

package/dist.dts/packages/daemon/src/registry.d.ts

@@ -0,0 +1,14 @@
+import type { Monitor, MonitorCreateInput, MonitorSource, SourceInput } from "@fdcn/sourcefed/core";
+import { GithubMonitor } from "@fdcn/sourcefed/provider-github";
+import { JiraMonitor } from "@fdcn/sourcefed/provider-jira";
+import { SlackMonitor } from "@fdcn/sourcefed/provider-slack";
+export declare const SOURCE_MAP: {
+    jira: JiraMonitor;
+    github: GithubMonitor;
+    slack: SlackMonitor;
+};
+export declare const SOURCE_TYPES: [string, ...string[]];
+export declare function sourceDefinition(source: MonitorSource): Monitor<any>;
+export declare function isSource(input: SourceInput): input is MonitorSource;
+export declare function sourceForInput(type: MonitorSource["type"], input: MonitorCreateInput): SourceInput;
+export declare function sourceForWebhookPath(pathname: string): Monitor<any> | undefined;

package/dist.dts/packages/daemon/src/types/client.d.ts

@@ -0,0 +1,21 @@
+import type { ChildProcess } from "node:child_process";
+import type { MonitorTarget, QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+export type DaemonClientOptions = {
+    name: string;
+    url?: string;
+    token?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
+export interface DaemonClient {
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    subscribe(target: MonitorTarget, onEvents: (events: QueuedMonitorEvent[]) => Promise<void>): Promise<{
+        close(): Promise<void>;
+    }>;
+    close(): Promise<void>;
+}
+export type SpawnDaemonResult = {
+    url: string;
+    proc?: ChildProcess;
+};

package/dist.dts/packages/daemon/src/types/daemon.d.ts

@@ -0,0 +1,58 @@
+import type { MonitorEventQueue, MonitorRecord, MonitorStore, QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+export type DaemonCreateInput = {
+    name: string;
+    sourceType: string;
+    issueKey?: string;
+    repo?: string;
+    prNumber?: number;
+    channelId?: string;
+    threadTs?: string;
+    threadUrl?: string;
+    pollIntervalSec?: number;
+};
+export type SourcefedDaemonOptions = {
+    store?: MonitorStore;
+    eventQueue?: MonitorEventQueue;
+    stateDir?: string;
+    pollLoopSec?: number;
+};
+export type MonitorView = {
+    id: string;
+    name: string;
+    source: MonitorRecord["source"];
+    target: MonitorRecord["target"];
+    delivery: MonitorRecord["delivery"];
+    pollIntervalSec: number;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    icon: string;
+    label: string;
+    detail: string;
+    describe: string;
+    unresponsive: boolean;
+};
+export type LogEntryView = {
+    id: string;
+    monitorID: string;
+    at: string;
+    kind: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+    icon: string;
+    describe: string;
+};
+export type DaemonResult = {
+    ok: true;
+    created?: boolean;
+    monitor?: MonitorView;
+    monitors?: MonitorView[];
+    events?: QueuedMonitorEvent[];
+    logs?: LogEntryView[];
+    acknowledged?: string[];
+    removed?: boolean;
+} | {
+    ok: false;
+    error: string;
+};

package/dist.dts/packages/daemon/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { DaemonCreateInput, DaemonResult, LogEntryView, MonitorView, SourcefedDaemonOptions } from "./daemon.js";
+export type { DaemonClient, DaemonClientOptions, SpawnDaemonResult } from "./client.js";
+export type { DaemonEventFrame, DaemonFrame, DaemonRequest, DaemonResponse } from "./protocol.js";

package/dist.dts/packages/daemon/src/types/protocol.d.ts

@@ -0,0 +1,21 @@
+import type { MonitorTarget, QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+export type DaemonRequest = {
+    id?: number;
+    method: string;
+    params?: Record<string, unknown>;
+};
+export type DaemonResponse = {
+    id?: number;
+    result?: unknown;
+    error?: string;
+};
+export type DaemonEventFrame = {
+    type: "event";
+    target: MonitorTarget;
+    events: QueuedMonitorEvent[];
+};
+export type DaemonFrame = DaemonResponse | DaemonEventFrame | {
+    type: "subscribed";
+    target: MonitorTarget;
+};
+export declare function parseDaemonFrame(line: string): DaemonFrame | undefined;

package/dist.dts/packages/daemon/src/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function daemonEnvironment(host?: string): Record<string, string>;

package/dist.dts/packages/daemon/src/utils/http-server.d.ts

@@ -0,0 +1,10 @@
+export type HttpServerOptions = {
+    hostname: string;
+    port: number;
+    handler: (request: Request) => Promise<Response> | Response;
+};
+export type HttpServer = {
+    port: number;
+    stop(): Promise<void>;
+};
+export declare function serveHttp(options: HttpServerOptions): Promise<HttpServer>;

package/dist.dts/packages/daemon/src/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { daemonEnvironment } from "./env.js";
+export { serveHttp, type HttpServer, type HttpServerOptions } from "./http-server.js";
+export { RequestRouter } from "./request-router.js";
+export { DEFAULT_DAEMON_URL, daemonCommand, defaultDaemonUrl, sleep, spawnLocalDaemon, withTimeout } from "./spawn.js";
+export { NotifyingEventSink } from "./sink.js";
+export { decodeTarget, encodeTarget, targetKey } from "./target.js";

package/dist.dts/packages/daemon/src/utils/request-router.d.ts

@@ -0,0 +1,11 @@
+export declare class RequestRouter {
+    private readonly pending;
+    private cursor;
+    nextID(): number;
+    register(id: number): Promise<unknown>;
+    settle(id: number, frame: {
+        result?: unknown;
+        error?: string;
+    }): void;
+    rejectAll(error: Error): void;
+}

package/dist.dts/packages/daemon/src/utils/sink.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorEventQueue, MonitorEventSink, MonitorRecord, MonitorTarget } from "@fdcn/sourcefed/core";
+export declare class NotifyingEventSink implements MonitorEventSink {
+    private readonly queue;
+    private readonly notify;
+    constructor(queue: MonitorEventQueue, notify: (target: MonitorTarget) => void);
+    deliver(input: {
+        monitor: MonitorRecord;
+        event: import("@fdcn/sourcefed/core").MonitorEvent;
+    }): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+}

package/dist.dts/packages/daemon/src/utils/spawn.d.ts

@@ -0,0 +1,19 @@
+import { type ChildProcess } from "node:child_process";
+export declare const DEFAULT_DAEMON_URL = "http://127.0.0.1:18787";
+export declare function defaultDaemonUrl(): string;
+export declare function daemonCommand(cliEntryPath: string): {
+    command: string;
+    args: string[];
+};
+export declare function spawnLocalDaemon(options: {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    port?: number;
+    timeoutMs?: number;
+}): Promise<{
+    url: string;
+    proc?: ChildProcess;
+}>;
+export declare function sleep(ms: number): Promise<void>;
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;

package/dist.dts/packages/daemon/src/utils/target.d.ts

@@ -0,0 +1,4 @@
+import type { MonitorTarget } from "@fdcn/sourcefed/core";
+export declare function encodeTarget(target: MonitorTarget): string;
+export declare function decodeTarget(value: string): MonitorTarget | undefined;
+export declare function targetKey(target: MonitorTarget): string;

package/dist.dts/packages/mcp/src/index.d.ts

@@ -0,0 +1,2 @@
+export { createSourcefedMcp, createSourcefedStdio, type SourcefedMcp, type SourcefedStdio } from "./server.js";
+export { decodeTarget, encodeTarget, eventResourceUri } from "./uris.js";

package/dist.dts/packages/mcp/src/server.d.ts

@@ -0,0 +1,14 @@
+import { createMcpHandler, McpServer } from "@modelcontextprotocol/server";
+import type { SourcefedDaemon } from "@fdcn/sourcefed/daemon";
+export type SourcefedMcp = {
+    runtime: SourcefedDaemon["runtime"];
+    handler: ReturnType<typeof createMcpHandler>;
+    close(): void;
+};
+export type SourcefedStdio = {
+    runtime: SourcefedDaemon["runtime"];
+    factory: () => McpServer;
+    close(): void;
+};
+export declare function createSourcefedMcp(daemon: SourcefedDaemon): SourcefedMcp;
+export declare function createSourcefedStdio(daemon: SourcefedDaemon): SourcefedStdio;

package/dist.dts/packages/mcp/src/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/packages/mcp/src/uris.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorTarget } from "@fdcn/sourcefed/core";
+export declare function eventResourceUri(target: MonitorTarget): string;
+export { decodeTarget, encodeTarget } from "@fdcn/sourcefed/daemon";

package/dist.dts/packages/sourcefed/src/server.d.ts

@@ -0,0 +1,7 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import Sourcefed from "../../../adapters/opencode/index.js";
+declare const _default: {
+    id: string;
+    server: (input: Parameters<typeof Sourcefed>[0]) => Promise<Hooks>;
+};
+export default _default;

package/dist.dts/providers/github/src/api/client.d.ts

@@ -0,0 +1,3 @@
+export declare function githubToken(): string | undefined;
+export declare function githubJson(path: string): Promise<any | undefined>;
+export declare function githubGraphQL(query: string, variables: Record<string, unknown>): Promise<any | undefined>;

package/dist.dts/providers/github/src/api/comments.d.ts

@@ -0,0 +1 @@
+export declare function fetchGithubComments(path: string): Promise<any[] | undefined>;

package/dist.dts/providers/github/src/api/github-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/providers/github/src/api/index.d.ts

@@ -0,0 +1,4 @@
+export { githubToken } from "./client.js";
+export { fetchGithubComments } from "./comments.js";
+export { fetchRunLog } from "./logs.js";
+export { fetchPrData } from "./pr.js";

package/dist.dts/providers/github/src/api/logs.d.ts

@@ -0,0 +1,5 @@
+export declare function fetchRunLog(repo: string, runId: string): Promise<string | undefined>;
+export declare function extractZipEntries(buffer: Uint8Array): {
+    name: string;
+    content: Uint8Array;
+}[];

package/dist.dts/providers/github/src/api/pr.d.ts

@@ -0,0 +1,8 @@
+export type GithubPrData = {
+    reviews: any[];
+    statusCheckRollup: any[];
+    mergeable?: string;
+    mergeStateStatus?: string;
+    state?: string;
+};
+export declare function fetchPrData(repo: string, prNumber: number): Promise<GithubPrData | undefined>;

package/dist.dts/providers/github/src/github.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/providers/github/src/index.d.ts

@@ -0,0 +1,2 @@
+export { GithubMonitor } from "./monitor.js";
+export type { GithubSourceRecord, GithubEvent, GithubCursor } from "./types";

package/dist.dts/providers/github/src/monitor.d.ts

@@ -0,0 +1,15 @@
+import { Monitor } from "@fdcn/sourcefed/core";
+import type { MonitorCreateInput } from "@fdcn/sourcefed/core";
+import type { GithubSourceRecord } from "./types";
+import type { SourceInput } from "@fdcn/sourcefed/core";
+export declare class GithubMonitor extends Monitor<GithubSourceRecord> {
+    readonly poll: import("@fdcn/sourcefed/core").PollMonitor<GithubSourceRecord>;
+    readonly webhook: import("@fdcn/sourcefed/core").WebhookMonitor<GithubSourceRecord>;
+    constructor();
+    readonly key: (source: GithubSourceRecord) => string;
+    readonly icon = "\uDB80\uDEA4";
+    readonly label: (source: GithubSourceRecord) => string;
+    readonly detail: (source: GithubSourceRecord) => string;
+    readonly describe: (source: GithubSourceRecord) => string;
+    build(input: MonitorCreateInput): SourceInput;
+}

package/dist.dts/providers/github/src/poll/index.d.ts

@@ -0,0 +1,2 @@
+export { githubPollMonitor } from "./monitor.js";
+export * from "./utils";

package/dist.dts/providers/github/src/poll/monitor.d.ts

@@ -0,0 +1,3 @@
+import { PollMonitor } from "@fdcn/sourcefed/core";
+import type { GithubSourceRecord } from "../types";
+export declare const githubPollMonitor: PollMonitor<GithubSourceRecord>;

package/dist.dts/providers/github/src/poll/utils/append-comments.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function appendComments(repo: string, prNumber: number, cursor: GithubCursor, events: GithubEvent[], comments: any[], idPrefix: string, historyPrimed: boolean, summary: (comment: any) => string, body: (comment: any) => string): void;

package/dist.dts/providers/github/src/poll/utils/append-github-ci-event.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function appendGithubCiEvent(repo: string, prNumber: number, cursor: GithubCursor, events: GithubEvent[], rollup: any[]): Promise<void>;

package/dist.dts/providers/github/src/poll/utils/append-github-conflict-event.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function appendGithubConflictEvent(repo: string, prNumber: number, cursor: GithubCursor, events: GithubEvent[], mergeable: string): void;

package/dist.dts/providers/github/src/poll/utils/append-github-reviews.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function appendGithubReviews(repo: string, prNumber: number, cursor: GithubCursor, events: GithubEvent[], reviews: any[], historyPrimed: boolean): void;

package/dist.dts/providers/github/src/poll/utils/append-github-state-event.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function appendGithubStateEvent(repo: string, prNumber: number, cursor: GithubCursor, events: GithubEvent[], prState: string): boolean;

package/dist.dts/providers/github/src/poll/utils/ci-failure-detail.d.ts

@@ -0,0 +1 @@
+export declare function ciFailureDetail(repo: string, failed: any[]): Promise<string>;

package/dist.dts/providers/github/src/poll/utils/clean-ci-log.d.ts

@@ -0,0 +1 @@
+export declare function cleanCiLog(raw: string): string;

package/dist.dts/providers/github/src/poll/utils/confirm-still-failing.d.ts

@@ -0,0 +1 @@
+export declare function confirmStillFailing(repo: string, prNumber: number, failed: any[]): Promise<any[]>;

package/dist.dts/providers/github/src/poll/utils/empty-cursor.d.ts

@@ -0,0 +1,2 @@
+import type { GithubCursor } from "../../types";
+export declare function emptyGithubCursor(): GithubCursor;

package/dist.dts/providers/github/src/poll/utils/failure-run-ids.d.ts

@@ -0,0 +1 @@
+export declare function failureRunIds(failed: any[]): Set<string>;

package/dist.dts/providers/github/src/poll/utils/failure-run-log.d.ts

@@ -0,0 +1 @@
+export declare function failureRunLog(repo: string, runId: string): Promise<string | undefined>;

package/dist.dts/providers/github/src/poll/utils/format-failed-check.d.ts

@@ -0,0 +1 @@
+export declare function formatFailedCheck(check: any): string;

package/dist.dts/providers/github/src/poll/utils/index.d.ts

@@ -0,0 +1 @@
+export { pollGithub } from "./poll-github.js";

package/dist.dts/providers/github/src/poll/utils/poll-github.d.ts

@@ -0,0 +1,6 @@
+import type { GithubCursor, GithubEvent } from "../../types";
+export declare function pollGithub(repo: string, prNumber: number, cursorRaw: unknown): Promise<{
+    events: GithubEvent[];
+    cursor: GithubCursor;
+    terminal: boolean;
+}>;

package/dist.dts/providers/github/src/poll/utils/poll-helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/providers/github/src/schema.d.ts

@@ -0,0 +1,17 @@
+import * as v from "valibot";
+export declare const GithubSourceSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"github", undefined>;
+    readonly repo: v.StringSchema<undefined>;
+    readonly prNumber: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const GithubCursorSchema: v.ObjectSchema<{
+    readonly reviewIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly commentIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly historyPrimed: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly lineCommentsPrimed: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly conversationCommentsPrimed: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly ciState: v.StringSchema<undefined>;
+    readonly ciFailureState: v.OptionalSchema<v.StringSchema<undefined>, "">;
+    readonly mergeable: v.StringSchema<undefined>;
+    readonly prState: v.StringSchema<undefined>;
+}, undefined>;

package/dist.dts/providers/github/src/types/cursor.d.ts

@@ -0,0 +1,11 @@
+export interface GithubCursor {
+    reviewIds: string[];
+    commentIds: string[];
+    historyPrimed: boolean;
+    lineCommentsPrimed: boolean;
+    conversationCommentsPrimed: boolean;
+    ciState: string;
+    ciFailureState: string;
+    mergeable: string;
+    prState: string;
+}

package/dist.dts/providers/github/src/types/event.d.ts

@@ -0,0 +1,11 @@
+export interface GithubEvent {
+    kind: "review" | "comment" | "ci" | "conflict" | "merged";
+    id?: string;
+    repo: string;
+    prNumber: number;
+    at: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+    terminal?: boolean;
+}

package/dist.dts/providers/github/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { GithubCursor } from "./cursor.js";
+export type { GithubEvent } from "./event.js";
+export type { GithubSourceRecord } from "./source-record.js";

package/dist.dts/providers/github/src/types/source-record.d.ts

@@ -0,0 +1,5 @@
+export type GithubSourceRecord = {
+    type: "github";
+    repo: string;
+    prNumber: number;
+};

package/dist.dts/providers/github/src/webhook/index.d.ts

@@ -0,0 +1,3 @@
+export { githubWebhookMonitor } from "./monitor.js";
+export * from "./types";
+export * from "./utils";

package/dist.dts/providers/github/src/webhook/monitor.d.ts

@@ -0,0 +1,3 @@
+import { WebhookMonitor } from "@fdcn/sourcefed/core";
+import type { GithubSourceRecord } from "../types";
+export declare const githubWebhookMonitor: WebhookMonitor<GithubSourceRecord>;

package/dist.dts/providers/github/src/webhook/types/context.d.ts

@@ -0,0 +1,7 @@
+export type GithubWebhookContext = {
+    payload: any;
+    actor: string;
+    repo: string;
+    prNumber: number;
+    eventName: string;
+};

package/dist.dts/providers/github/src/webhook/types/event-handler.d.ts

@@ -0,0 +1,3 @@
+import type { GithubWebhookContext } from "./context.js";
+import type { GithubEventShape } from "./event-shape.js";
+export type GithubEventHandler = (context: GithubWebhookContext) => GithubEventShape;

package/dist.dts/providers/github/src/webhook/types/event-shape.d.ts

@@ -0,0 +1,7 @@
+export type GithubEventShape = {
+    kind: string;
+    id?: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+};

package/dist.dts/providers/github/src/webhook/types/index.d.ts

@@ -0,0 +1 @@
+export type { GithubEventHandler } from "./event-handler.js";

package/dist.dts/providers/github/src/webhook/utils/fallback-github-event.d.ts

@@ -0,0 +1,3 @@
+import type { GithubEventShape } from "../types/event-shape.js";
+import type { GithubWebhookContext } from "../types/context.js";
+export declare function fallbackGithubEvent({ payload, actor, repo, prNumber, eventName }: GithubWebhookContext): GithubEventShape;

package/dist.dts/providers/github/src/webhook/utils/github-event-handlers.d.ts

@@ -0,0 +1,2 @@
+import type { GithubEventHandler } from "../types";
+export declare const githubEventHandlers: Record<string, GithubEventHandler>;