@bridge-ds/core 0.16.0 → 0.18.0

package/dist/activity.d.ts

@@ -0,0 +1,207 @@
+import { type FetchLike } from './github-client';
+import type { BridgeConfig } from './config';
+import { type HistoryReport } from './history';
+import { type RequestKind, type RequestStatus } from './requests';
+import type { RiskTier } from './risk';
+import type { SuggestionKind, SuggestionPayloadV1, SuggestionStatus } from './suggestions';
+export declare const ACTIVITY_SCHEMA_VERSION = 1;
+/** Next to snapshot.json on the bridge-data branch. */
+export declare const ACTIVITY_FILE = "activity.json";
+/** Above this, the recorded reads are dropped heaviest first (trees, then older branches) until it fits. */
+export declare const ACTIVITY_MAX_BYTES = 3000000;
+/** A guest reads activity.json while it is younger than this; older, the Studio reads GitHub live. */
+export declare const ACTIVITY_MAX_AGE_MS: number;
+/** How much one activity.json carries. Each is a count of items, newest first. */
+export declare const ACTIVITY_LIMITS: {
+    /** Open pull requests recorded in full (the page of each; the list carries every open one). */
+    readonly branches: 30;
+    /** Open suggestions read with their comments (parsed payload, counted approvals). */
+    readonly suggestions: 30;
+    /** Request issues listed (open and closed); open ones are read with their comments. */
+    readonly requests: 30;
+    /** Merged pull requests summarized. */
+    readonly merged: 20;
+    /** Token history entries (core loadGitHubHistory limit). */
+    readonly history: 20;
+    /** History entries whose two commits' file lists are recorded, so their before/after opens without the API. */
+    readonly historyTrees: 10;
+};
+export type ActivityLimits = {
+    [K in keyof typeof ACTIVITY_LIMITS]: number;
+};
+/** One GitHub answer: its status (200, or 404 for a read that finds nothing) and its JSON body, trimmed. */
+export interface ActivityResponse {
+    status: number;
+    body: unknown;
+}
+export interface ActivityBranch {
+    number: number;
+    title: string;
+    author: string;
+    url: string;
+    branch: string;
+    base: string;
+    headSha: string;
+    baseSha: string;
+    state: 'open' | 'draft';
+    labels: string[];
+    /** Risk tier from the labels, the body or the files (review-gate effectiveTier); null when none says. */
+    tier: RiskTier | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Conversation plus line comments. Null when the branch was not read in full (over the limit). */
+    comments: number | null;
+    /** Files the branch changes, and the token files among them (the token diff opens from them). Null: not read. */
+    files: {
+        changed: number;
+        tokens: string[];
+    } | null;
+    /** Previews built for the head commit (commit statuses with a link, success only). */
+    previews: {
+        context: string;
+        url: string;
+    }[];
+    /** Combined check state of the head commit. */
+    checks: 'success' | 'failure' | 'pending' | 'none' | null;
+}
+export interface ActivitySuggestion {
+    number: number;
+    title: string;
+    author: string;
+    url: string;
+    createdAt: string;
+    kind: SuggestionKind | null;
+    status: SuggestionStatus;
+    labels: string[];
+    comments: number | null;
+    /** The parsed suggestion (null when its block does not parse). */
+    payload: SuggestionPayloadV1 | null;
+    approvers: string[];
+}
+export interface ActivityRequest {
+    number: number;
+    title: string;
+    author: string;
+    url: string;
+    state: 'open' | 'closed';
+    status: RequestStatus;
+    kind: RequestKind | null;
+    component: string | null;
+    labels: string[];
+    createdAt: string;
+}
+export interface ActivityMerged {
+    number: number;
+    title: string;
+    author: string;
+    url: string;
+    mergedAt: string;
+    labels: string[];
+    tier: RiskTier | null;
+}
+export interface RepoActivity {
+    kind: 'bridge-activity';
+    schemaVersion: typeof ACTIVITY_SCHEMA_VERSION;
+    tool: {
+        name: 'bridge';
+        version: string;
+    };
+    generatedAt: string;
+    repo: {
+        owner: string;
+        name: string;
+        branch: string;
+    };
+    /** Default branch head when it was written. */
+    headSha: string;
+    branches: ActivityBranch[];
+    suggestions: ActivitySuggestion[];
+    requests: ActivityRequest[];
+    merged: ActivityMerged[];
+    /** Token history of the default branch (core HistoryReport), null when it could not be read. */
+    history: HistoryReport | null;
+    /** GitHub REST answers by activityKey (path relative to api.github.com, query sorted). */
+    responses: Record<string, ActivityResponse>;
+    /** What was left out to stay within the limits, in words. */
+    truncated: string[];
+    /** What could not be read. */
+    problems: string[];
+}
+export declare class ActivityError extends Error {
+}
+/**
+ * The key of a GitHub REST read: the path relative to api.github.com with the query parameters sorted, and the
+ * owner and repository (or user) lowercased, since GitHub reads them without case. Null for any other host.
+ */
+export declare function activityKey(url: string): string | null;
+/**
+ * A GitHub answer without what no page reads: API links, node ids, diffs, reactions, the repository objects nested in
+ * a pull request's head and base (name, owner and fork kept), and user objects beyond login, avatar and type. A tree
+ * keeps path, type and sha per entry. Strings longer than 60 000 characters are cut.
+ */
+export declare function trimGitHub(value: unknown, key?: string): unknown;
+/** What a recordingFetch shaper returns for a read it should not keep. */
+export declare const SKIP: unique symbol;
+/**
+ * The paths of a tree the Studio reads from a recorded tree: token files and the contrast checks (the branch token
+ * diff), bridge.config.json, changesets, and the CHANGELOG.md and package.json the history reads. Every other entry is
+ * left out of activity.json, which keeps a tree at a few kilobytes instead of a whole repository listing.
+ */
+export declare function activityTreeFilter(config: BridgeConfig): (path: string) => boolean;
+/** The shaper collectActivity records with: trees filtered (activityTreeFilter), compares to what a branch page reads. */
+export declare function activityShaper(config: BridgeConfig): (key: string, body: unknown) => unknown | typeof SKIP;
+/** Changes listed per history entry; an import of hundreds of tokens keeps its counts and its first changes. */
+export declare const HISTORY_MAX_CHANGES = 100;
+/** A history report with each entry's change and reason lists capped (counts stay whole). */
+export declare function capHistory(report: HistoryReport, max?: number): HistoryReport;
+/**
+ * Wraps a fetch and records every GitHub REST GET that answers 200 or 404 with JSON, trimmed, under its activityKey.
+ * Reads with another media type (raw file bodies) pass through unrecorded.
+ */
+export declare function recordingFetch(fetchImpl: FetchLike, into: Map<string, ActivityResponse>, shape?: (key: string, body: unknown) => unknown | typeof SKIP): FetchLike;
+export interface CollectActivityInput {
+    /** fetch for api.github.com (the token goes in `token`). */
+    fetch: FetchLike;
+    token: string;
+    owner: string;
+    repo: string;
+    /** The repository's Bridge config (tokens root, governance, changesets): history and suggestion approvals read it. */
+    config: BridgeConfig;
+    version: string;
+    generatedAt?: string;
+    /**
+     * The activity published last time. Its history (and the file lists recorded for it) is kept when the default
+     * branch head has not moved, which saves most of the reads of a run on a schedule or a pull request event.
+     */
+    previous?: RepoActivity | null;
+    limits?: Partial<ActivityLimits>;
+}
+/**
+ * Reads the team's activity from GitHub: the same reads, with the same paths, as the hosted Studio's guest pages
+ * (Home, Branches and each open branch, Review, History, suggestions, requests), recorded, plus the summaries. A read
+ * that fails is noted in `problems` and the rest goes on; an exhausted hourly limit stops the reading there.
+ */
+export declare function collectActivity(input: CollectActivityInput): Promise<RepoActivity>;
+/** Bytes of the activity as written. */
+export declare const activityBytes: (a: RepoActivity) => number;
+/**
+ * Keeps the activity under `max` bytes: drops the recorded file lists (trees) first, then the pages of the least
+ * recently updated branches, then every recorded read. The summaries always stay. Says what it dropped in `truncated`.
+ */
+export declare function fitActivity(activity: RepoActivity, max?: number): RepoActivity;
+/** Validates an activity (text or parsed JSON). Throws ActivityError naming the first problem. */
+export declare function parseActivity(input: string | unknown): RepoActivity;
+/** Milliseconds since the activity was written (never negative). */
+export declare const activityAge: (a: Pick<RepoActivity, "generatedAt">, now?: number) => number;
+/** True while a guest should read the activity instead of GitHub: written for this repository, and recently. */
+export declare function activityIsUsable(a: Pick<RepoActivity, 'generatedAt' | 'repo'>, team: {
+    owner: string;
+    repo: string;
+}, now?: number, maxAge?: number): boolean;
+/**
+ * The recorded answer to a GitHub REST GET, or undefined when the activity did not record it (read it live). Only
+ * reads of the activity's own repository (and the user accounts it recorded) are answered.
+ */
+export declare function activityAnswer(a: Pick<RepoActivity, 'responses' | 'repo'>, url: string): ActivityResponse | undefined;
+/** "activity.json" on the bridge-data branch of a public repository, on the raw host (no API quota). */
+export declare const activityRawUrl: (owner: string, repo: string) => string;

package/dist/audit/index.js

@@ -1,6 +1,6 @@
-import { i as isAuditable, a as auditFile } from "../report-DbE6yJCw.js";
-import { A, b, c, C, D, d, F, I, L, e, M, N, f, g, h, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, B, E, G, H, J, K, O, P, Q, R, S, T, U, V, W, X, Y, Z } from "../report-DbE6yJCw.js";
-import { p as pieceId, a as proposedTokenPath, t as tokenLabel } from "../prod-branch-CSM0c2OF.js";
+import { i as isAuditable, a as auditFile } from "../report-DVEmUr0p.js";
+import { A, b, c, C, D, d, F, I, L, e, M, N, f, g, h, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, B, E, G, H, J, K, O, P, Q, R, S, T, U, V, W, X, Y, Z } from "../report-DVEmUr0p.js";
+import { p as pieceId, a as proposedTokenPath, t as tokenLabel } from "../prod-branch-DenQkr_e.js";
 const lines = (text) => text.split(/\r?\n/);
 function lineBag(text) {
   const bag = /* @__PURE__ */ new Map();

package/dist/index.d.ts

@@ -60,6 +60,7 @@ export * from './token-proposal';
 export * from './figma-push';
 export * from './figma-push-github';
 export * from './suggestions';
+export * from './titles';
 export * from './suggestion-review';
 export * from './suggestions-github';
 export * from './suggestion-apply';
@@ -72,3 +73,4 @@ export * from './repo-model';
 export * from './repo-source-github';
 export * from './repo-access';
 export * from './snapshot';
+export * from './activity';