@bridge-ds/mcp 0.0.0-stage → 0.2.0

package/dist/components.d.ts

@@ -0,0 +1,55 @@
+import type { BridgeConfig } from './config.js';
+import type { RepoSource } from './source.js';
+import type { TokenSet } from './core-adapter.js';
+export interface PropInfo {
+    name: string;
+    type: string;
+    optional: boolean;
+    default?: string;
+    description?: string;
+    /** Literal values when the type is a local union alias (ButtonVariant -> primary | secondary ...). */
+    values?: string[];
+}
+export interface ComponentSummary {
+    name: string;
+    family?: string;
+    summary?: string;
+}
+export declare function listComponentNames(source: RepoSource, config: BridgeConfig): Promise<{
+    name: string;
+    files: string[];
+}[]>;
+export declare function listComponents(source: RepoSource, config: BridgeConfig, withSummaries: boolean): Promise<ComponentSummary[]>;
+export declare function parseProps(src: string, name: string): {
+    extends?: string;
+    props: PropInfo[];
+} | null;
+export declare function cssVarsUsed(css: string): string[];
+export declare function getComponent(source: RepoSource, config: BridgeConfig, set: TokenSet | null, name: string): Promise<{
+    tokens: {
+        notTokens?: string[] | undefined;
+        used: string[];
+    };
+    stories: string[];
+    extends?: string | undefined;
+    props: PropInfo[];
+    docs?: Record<string, unknown> | undefined;
+    name: string;
+    family: string | undefined;
+    files: string[];
+}>;
+export interface ScaffoldInput {
+    name: string;
+    family: string;
+    summary: string;
+    element: string;
+    interactive: boolean;
+    basePrimitive?: string;
+}
+export declare function scaffoldComponent(source: RepoSource, config: BridgeConfig, set: TokenSet, input: ScaffoldInput): Promise<{
+    files: {
+        path: string;
+        content: string;
+    }[];
+    notes: string[];
+}>;

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import { type BridgeConfig, CONFIG_FILE, loadConfig, toConfigJson } from '@bridge-ds/core';
+export { CONFIG_FILE, loadConfig as parseConfig, toConfigJson, type BridgeConfig };
+/** Where `bridge init` points "$schema" in a detected config. */
+export declare const SCHEMA_URL = "https://raw.githubusercontent.com/peterbono/ai-design-system-demo/main/packages/core/bridge.config.schema.json";
+/**
+ * Builds a config from a file list. `read` returns file contents (to tell token JSON from other JSON).
+ * Heuristic: finds the directory that holds the token files, maps sub-directories to tiers by name,
+ * and turns light/dark (and density) file names into modes.
+ */
+export declare function detectConfig(files: string[], read: (p: string) => Promise<string | null>, extra?: {
+    repo?: string;
+    branch?: string;
+}): Promise<BridgeConfig>;

package/dist/context.d.ts

@@ -0,0 +1,42 @@
+import { type BridgeConfig } from './config.js';
+import { GitHubClient, type TokenSet } from './core-adapter.js';
+import { type RepoSource } from './source.js';
+export interface ContextOptions {
+    /** Local repo root (default: cwd). Ignored when `repo` is set. */
+    root?: string;
+    /** Remote mode: GitHub `owner/name`. */
+    repo?: string;
+    /** Remote ref to read (default: the repo's default branch). */
+    ref?: string;
+    /** GitHub token. Without one Bridge is read-only. */
+    token?: string;
+    fetch?: typeof fetch;
+    apiUrl?: string;
+    rawUrl?: string;
+}
+export declare class BridgeContext {
+    readonly mode: 'local' | 'remote';
+    readonly source: RepoSource;
+    readonly opts: ContextOptions;
+    readonly root?: string | undefined;
+    readonly isGit: boolean;
+    private cached?;
+    private cachedSet?;
+    private gh?;
+    private constructor();
+    static create(opts?: ContextOptions): Promise<BridgeContext>;
+    get ref(): string | undefined;
+    config(): Promise<{
+        config: BridgeConfig;
+        origin: 'file' | 'detected';
+    }>;
+    /** Token set at the current state. Local mode re-reads files on every call so edits show up at once. */
+    tokens(): Promise<TokenSet>;
+    /**
+     * GitHub client for reviews and remote writes, guarded by the config: protected branches plus the base
+     * branch are refused, new branches need the agent prefix. Local mode uses config.repo or the origin remote.
+     */
+    github(): Promise<GitHubClient | null>;
+    get canWriteRemote(): boolean;
+    describe(): string;
+}

package/dist/core-adapter.d.ts

@@ -0,0 +1,48 @@
+import { type BridgeConfig, type ChangeTier, type ContrastDelta, type ContrastPair, type EditResult, type ImpactEntry, type LayerIssue, type LayeredChange, type LayeredContrastResult, type LayeredResolution, type ProposalBodyInput, type Rgba, type SemverBump, type TokenEdit, changeTable, checkLayeredPair, comboKey, contrastDeltaTable, GitHubClient, GitHubError, LayeredTokenSet, parseRepo, rgbaToHex } from '@bridge-ds/core';
+import type { RepoSource } from './source.js';
+export type { Combo } from '@bridge-ds/core';
+export type Issue = LayerIssue;
+export type Resolved = LayeredResolution;
+export type TokenSet = LayeredTokenSet;
+export type ContrastResult = LayeredContrastResult;
+export type TokenChange = LayeredChange;
+export type TierResult = ChangeTier;
+export type { ContrastDelta, ContrastPair, EditResult, ImpactEntry, TokenEdit };
+export { GitHubClient, GitHubError, LayeredTokenSet };
+/** Pair as MCP clients pass it: `{ fg, bg, min }`. */
+export interface PairInput {
+    fg: string;
+    bg: string;
+    min: number;
+}
+export interface BridgeCore {
+    loadTokenSet(source: RepoSource, config: BridgeConfig): Promise<TokenSet>;
+    tokenSetFromFiles(config: BridgeConfig, files: Map<string, string>): TokenSet;
+    validate(set: TokenSet): Issue[];
+    parityIssues(set: TokenSet): Issue[];
+    readContrastPairs(source: RepoSource, config: BridgeConfig): Promise<ContrastPair[]>;
+    toPairs(input: PairInput[]): ContrastPair[];
+    runContrast(set: TokenSet, pairs: ContrastPair[], modes?: string[]): ContrastResult[];
+    checkPair: typeof checkLayeredPair;
+    contrastDelta(before: ContrastResult[], after: ContrastResult[]): ContrastDelta[];
+    applyEdits(set: TokenSet, edits: TokenEdit[]): EditResult;
+    coerceValue(input: unknown, type?: string, existing?: unknown): unknown;
+    diff(before: TokenSet, after: TokenSet): TokenChange[];
+    impact(before: TokenSet, after: TokenSet, direct: TokenChange[], limit?: number): {
+        total: number;
+        entries: ImpactEntry[];
+    };
+    /** The shared classifier (risk.ts in @bridge-ds/core). */
+    classify(changes: TokenChange[], otherFiles?: string[], config?: BridgeConfig): TierResult;
+    prBody(input: ProposalBodyInput): string;
+    changeset(pkg: string, bump: SemverBump, summary: string): string;
+    tokenTable: typeof changeTable;
+    contrastTable: typeof contrastDeltaTable;
+    slugify(text: string): string;
+    comboKey: typeof comboKey;
+    toRgba(v: unknown): Rgba | null;
+    rgbaToHex: typeof rgbaToHex;
+    parseRepo: typeof parseRepo;
+}
+export declare function readTokenFiles(source: RepoSource, config: BridgeConfig): Promise<Map<string, string>>;
+export declare const core: BridgeCore;

package/dist/drafts.d.ts

@@ -0,0 +1,46 @@
+import { type PendingDrafts } from '@bridge-ds/core';
+import type { BridgeContext } from './context.js';
+/** Images larger than this are linked, not inlined (bytes of PNG). */
+export declare const IMAGE_INLINE_MAX = 750000;
+/** At most this many images inlined per call, so the answer stays small. */
+export declare const IMAGES_PER_CALL = 8;
+export interface InlineImage {
+    sessionId: string;
+    itemId: string;
+    label: 'before' | 'after';
+    base64: string;
+}
+export interface PendingDraftsAnswer {
+    repo: string;
+    branch: string;
+    phrase: string;
+    sessions: (Pick<PendingDrafts, 'sessionId' | 'createdAt' | 'status' | 'items'> & {
+        briefs: string[];
+    })[];
+    voice: string[];
+    contract: string[];
+    next: string;
+}
+/** Pending sessions (newest first) or one session, with a brief per item and the images to inline. */
+export declare function pendingDrafts(ctx: BridgeContext, a: {
+    sessionId?: string | undefined;
+    images?: boolean | undefined;
+}): Promise<{
+    answer: PendingDraftsAnswer;
+    images: InlineImage[];
+}>;
+/** Writes Claude's texts into a session (sanitized, status "drafted" once every item has one), retrying on 409. */
+export declare function writeDrafts(ctx: BridgeContext, a: {
+    sessionId: string;
+    results: {
+        id: string;
+        title: string;
+        summary: string;
+    }[];
+}): Promise<{
+    next: string;
+    waiting?: string[] | undefined;
+    sessionId: string;
+    status: import("@bridge-ds/core").DraftSessionStatus;
+    results: import("@bridge-ds/core").DraftResult[];
+}>;

package/dist/explorations.d.ts

@@ -0,0 +1,168 @@
+import { explorationRules } from '@bridge-ds/core';
+import { BridgeContext } from './context.js';
+/** `explore/<slug>` from a branch, a slug or a name; throws with how to fix it when it cannot be one. */
+export declare function toExplorationBranch(ref: string): string;
+export interface StartExplorationInput {
+    name: string;
+    purpose: string;
+    useCase?: string | undefined;
+    experimental?: string[] | undefined;
+    author?: string | undefined;
+    dryRun?: boolean | undefined;
+}
+/**
+ * bridge_start_exploration / `bridge explore start`. With a GitHub token: the branch on GitHub from the default branch
+ * and a draft pull request labeled exploration. Without one, in a local git repo: a local branch with the note,
+ * nothing pushed, and the commands to push it and open the draft pull request.
+ */
+export declare function startExploration(ctx: BridgeContext, a: StartExplorationInput): Promise<{
+    branch: string;
+    slug: string;
+    base: string;
+    title: string;
+    label: string;
+    note: {
+        path: string;
+        content: string;
+    };
+    prBody: string;
+    status: "dry-run";
+} | {
+    pr: number;
+    url: string;
+    commit: string;
+    install: import("@bridge-ds/core").ExplorationInstall;
+    previews: {
+        app: string;
+        label: string;
+        url: string;
+    }[];
+    next: string;
+    branch: string;
+    slug: string;
+    base: string;
+    title: string;
+    label: string;
+    note: {
+        path: string;
+        content: string;
+    };
+    prBody: string;
+    status: "started";
+} | {
+    commit: string;
+    next: string;
+    branch: string;
+    slug: string;
+    base: string;
+    title: string;
+    label: string;
+    note: {
+        path: string;
+        content: string;
+    };
+    prBody: string;
+    status: "branch-created";
+}>;
+/** bridge_list_explorations / `bridge explore list`. */
+export declare function listExplorations(ctx: BridgeContext, a?: {
+    state?: 'open' | 'closed' | 'all';
+}): Promise<{
+    localBranches?: string[] | undefined;
+    localHint?: string | undefined;
+    repo: string;
+    label: string;
+    running: number;
+    total: number;
+    summary: string;
+    explorations: {
+        requests: {
+            number: number;
+            title: string;
+            url: string;
+            state: string;
+        }[];
+        number: number;
+        url: string;
+        branch: string;
+        slug: string;
+        name: string;
+        purpose: string;
+        useCase?: string | undefined;
+        status: import("@bridge-ds/core").ExplorationStatus;
+        draft: boolean;
+        author: string;
+        updatedAt: string;
+        previews: {
+            app: string;
+            label: string;
+            url: string;
+        }[];
+        install: import("@bridge-ds/core").ExplorationInstall;
+    }[];
+}>;
+/** `bridge explore promote`: ready for review, tier labels, exploration label and note removed, linked requests closed on merge. */
+export declare function promoteExploration(ctx: BridgeContext, a: {
+    ref: string;
+    dryRun?: boolean | undefined;
+}): Promise<{
+    closes: number[];
+    number: number;
+    url: string;
+    branch: string;
+    warnings: string[];
+    tier: import("@bridge-ds/core").RiskTier;
+    reasons: string[];
+    removeLabels: string[];
+    addLabels: string[];
+    removeFiles: string[];
+    body: string;
+    title: string;
+    markReady: true;
+    status: "promoted" | "dry-run";
+}>;
+export declare function closeExploration(ctx: BridgeContext, a: {
+    ref: string;
+}): Promise<{
+    number: number;
+    url: string;
+    branch: string;
+    status: "closed";
+}>;
+/**
+ * The context a write aimed at an exploration branch reads from. Remote: the same repo at that branch (it must
+ * exist). Local: the working tree, which must have that branch checked out, so Claude works where the designer is.
+ */
+export declare function explorationContext(ctx: BridgeContext, ref: string, opts?: {
+    requireCheckout?: boolean;
+}): Promise<{
+    ctx: BridgeContext;
+    branch: string;
+}>;
+/** Writes proposal files on an exploration: a commit on the GitHub branch (remote) or the checked-out working tree (local). */
+export declare function writeToExploration(ctx: BridgeContext, branch: string, input: {
+    message: string;
+    files: {
+        path: string;
+        content: string | null;
+    }[];
+}): Promise<{
+    status: "preview";
+    message: string;
+    branch?: undefined;
+    next?: undefined;
+} | {
+    next: string;
+    pr?: number | undefined;
+    url?: string | undefined;
+    status: "committed";
+    branch: string;
+    commit: string;
+    message?: undefined;
+} | {
+    status: "written";
+    branch: string;
+    next: string;
+    message?: undefined;
+}>;
+export { explorationRules };