@dxos/plugin-github 0.7.4 → 0.14.0

package/src/stories/PullRequestsArticle.stories.tsx

@@ -0,0 +1,170 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+import { expect, waitFor, within } from 'storybook/test';
+
+import * as Capabilities from '@dxos/app-framework/Capabilities';
+import * as Capability from '@dxos/app-framework/Capability';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as Operation from '@dxos/compute/Operation';
+import * as OperationHandlerSet from '@dxos/compute/OperationHandlerSet';
+import { Ref } from '@dxos/echo';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import * as CorePlugins from '@dxos/plugin-testing/CorePlugins';
+import { type Space, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { PullRequest, Task } from '@dxos/types';
+
+import { translations } from '#translations';
+import { GitHubOperation } from '#types';
+
+import { PullRequestsArticle } from '../containers/PullRequestsArticle/PullRequestsArticle.tsx';
+
+const DAY = 24 * 60 * 60_000;
+const daysAgo = (days: number) => new Date(Date.now() - days * DAY).toISOString();
+
+/** Number → the live standing the fixture answers with; absent numbers report no CI. */
+const STATUS: Record<number, { ci: GitHubOperation.CiState; review: GitHubOperation.ReviewState }> = {
+  13410: { ci: 'failure', review: 'none' },
+  13402: { ci: 'success', review: 'approved' },
+  13398: { ci: 'pending', review: 'none' },
+  412: { ci: 'success', review: 'changes_requested' },
+};
+
+/** Answers each row's status read from fixtures, so the story needs no connection or network. */
+const handlers = OperationHandlerSet.make(
+  Operation.withHandler(GitHubOperation.GetPullRequestStatus, ({ pullRequest }) =>
+    Effect.gen(function* () {
+      const target = yield* Effect.promise(() => pullRequest.load());
+      const { ci, review } = STATUS[target.number] ?? { ci: 'none' as const, review: 'none' as const };
+      const total = ci === 'none' ? 0 : 12;
+      return {
+        state: target.state,
+        title: target.title,
+        ci,
+        checks: {
+          total,
+          passed: ci === 'success' ? total : ci === 'failure' ? total - 2 : total - 3,
+          failed: ci === 'failure' ? 2 : 0,
+          pending: ci === 'pending' ? 3 : 0,
+        },
+        runs: [],
+        review,
+        approvals: review === 'approved' ? 2 : 0,
+      };
+    }),
+  ),
+);
+
+const seed = (space: Space) => {
+  const make = (props: Partial<Parameters<typeof PullRequest.make>[0]> & { number: number; title: string }) =>
+    space.db.add(PullRequest.make({ owner: 'dxos', repo: 'dxos', state: 'open', ...props }));
+
+  const failing = make({
+    number: 13410,
+    title: 'echo: memoize the index rebuild across reconnects',
+    author: 'wittjosiah',
+    updatedAt: daysAgo(0.1),
+  });
+  make({
+    number: 13402,
+    title: 'plugin-github: pull request triage list',
+    author: 'dmaretskyi',
+    updatedAt: daysAgo(1),
+  });
+  make({
+    number: 13398,
+    title: 'react-ui-menu: generic sort and group menus',
+    author: 'burdon',
+    updatedAt: daysAgo(2),
+  });
+  make({ number: 13377, title: 'docs: walkthrough fixtures', author: 'burdon', state: 'draft', updatedAt: daysAgo(6) });
+  make({
+    number: 13301,
+    title: 'tasks: milestone grouping',
+    author: 'richburdon',
+    state: 'merged',
+    updatedAt: daysAgo(9),
+  });
+  make({
+    number: 13250,
+    title: 'Revert flaky storybook watcher',
+    author: 'wittjosiah',
+    state: 'closed',
+    updatedAt: daysAgo(20),
+  });
+  make({
+    repo: 'edge',
+    number: 412,
+    title: 'router: forward trace context to db-service',
+    author: 'dmaretskyi',
+    updatedAt: daysAgo(3),
+  });
+
+  space.db.add(Task.make({ title: 'Fix index rebuild', status: 'started', artifacts: [Ref.make(failing)] }));
+};
+
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  if (!space) {
+    return <Loading data={{ space: false }} />;
+  }
+  return (
+    <div className='dx-expand'>
+      <PullRequestsArticle role='article' attendableId='story' db={space.db} />
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-github/stories/PullRequestsArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      capabilities: [
+        Capability.contribute(AppCapabilities.Translations, translations),
+        Capability.contribute(Capabilities.OperationHandler, handlers),
+      ],
+      plugins: [
+        ...CorePlugins.make(),
+        ClientPlugin.make({
+          types: [PullRequest.PullRequest, Task.Task],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { defaultSpace } = yield* initializeIdentity(client);
+              yield* Effect.promise(async () => {
+                seed(defaultSpace);
+                await defaultSpace.db.flush({ indexes: true });
+              });
+            }),
+        }),
+      ],
+    }),
+  ],
+  parameters: { layout: 'fullscreen', translations },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/** Ordered by relevance: the open pull request with failing CI (and a task tracking it) leads. */
+export const Default: Story = {
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const rows = await canvas.findAllByTestId('pull-requests.row', {}, { timeout: 10_000 });
+    await expect(rows).toHaveLength(7);
+    await waitFor(
+      () => expect(within(rows[0]).getByTestId('pull-requests.row.checks').textContent).toContain('CI failing'),
+      { timeout: 10_000 },
+    );
+    await expect(within(rows[0]).getByTestId('pull-requests.row.tasks').textContent).toContain('Fix index rebuild');
+  },
+};

package/src/stories/Walkthrough.stories.tsx

@@ -0,0 +1,110 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useRef, useState } from 'react';
+import { expect, waitFor } from 'storybook/test';
+
+import * as Panel from '@dxos/react-ui/Panel';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { type DiffLayout, type DiffLineTarget } from '@dxos/ui-editor';
+
+import { translations } from '#translations';
+
+import { LineCommentPopover } from '../components/CommentComposer/index.ts';
+import { WalkthroughView } from '../components/WalkthroughView/index.ts';
+import { WALKTHROUGH } from './walkthrough-fixture.ts';
+
+type StoryArgs = {
+  text: string;
+  layout?: DiffLayout;
+  sidebar?: 'full' | 'stats' | 'none';
+  /** Offer the hover comment button on each diff line, and float the composer at the line picked. */
+  comments?: boolean;
+};
+
+/**
+ * A walkthrough is ONE markdown document: the ```diff fences are block widgets inside it, not a
+ * separate diff view the prose is wrapped around.
+ */
+const DefaultStory = ({ text, layout, sidebar = 'full', comments }: StoryArgs) => {
+  const [target, setTarget] = useState<DiffLineTarget>();
+  const [comment, setComment] = useState('');
+  const anchorRef = useRef<HTMLElement | null>(null);
+
+  const handleLineComment = useCallback((next: DiffLineTarget, anchor: HTMLElement) => {
+    anchorRef.current = anchor;
+    setTarget(next);
+  }, []);
+
+  const handleCancel = useCallback(() => {
+    setTarget(undefined);
+    anchorRef.current = null;
+  }, []);
+
+  return (
+    <Panel.Root>
+      <Panel.Body>
+        <WalkthroughView
+          value={text}
+          layout={layout}
+          sidebar={sidebar}
+          onLineComment={comments ? handleLineComment : undefined}
+        />
+      </Panel.Body>
+      <LineCommentPopover
+        open={!!target}
+        anchorRef={anchorRef}
+        target={target}
+        value={comment}
+        onValueChange={setComment}
+        onSubmit={handleCancel}
+        onCancel={handleCancel}
+      />
+    </Panel.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-github/stories/Walkthrough',
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
+  parameters: { layout: 'fullscreen', controls: { disable: true }, translations },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/** The whole thing: prose, headings, side-by-side chunks and the navigation rail. */
+export const Default: Story = {
+  args: { text: WALKTHROUGH },
+  play: async ({ canvasElement }) => {
+    // The rail overflows in a short pane; it must scroll with the app's scrollbar, not the browser's.
+    await waitFor(() => expect(canvasElement.querySelector('.cm-walkthrough-sidebar')).not.toBeNull(), {
+      timeout: 10_000,
+    });
+    await expect(canvasElement.querySelector('.cm-walkthrough-sidebar')).toHaveClass('dx-scrollbar-thin');
+  },
+};
+
+/** The rail Graphite collapses to when the reader wants the width back. */
+export const StatsRail: Story = {
+  args: { text: WALKTHROUGH, sidebar: 'stats' },
+};
+
+/** Unified chunks, which is also what the side-by-side layout falls back to in a narrow pane. */
+export const Inline: Story = {
+  args: { text: WALKTHROUGH, layout: 'inline', sidebar: 'none' },
+};
+
+/** No rail, so the chunks are the only thing the document adds to plain markdown. */
+export const Chunks: Story = {
+  args: { text: WALKTHROUGH, sidebar: 'none' },
+};
+
+/** The comment composer floats at the diff line it addresses, not in a band above the document. */
+export const LineComment: Story = {
+  args: { text: WALKTHROUGH, comments: true, sidebar: 'none' },
+};

package/src/stories/github.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { parsePullRequestUrl } from './github.ts';
+
+describe('parsePullRequestUrl', () => {
+  test('reads owner, repository and number', () => {
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos/pull/13082')).to.deep.eq({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 13082,
+    });
+  });
+
+  test('tolerates www, a trailing path and surrounding space', () => {
+    expect(parsePullRequestUrl('  https://www.github.com/dxos/dxos/pull/13082/files  ')).to.deep.eq({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 13082,
+    });
+  });
+
+  test('keeps a query string out of the number', () => {
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos/pull/13082?w=1#issuecomment-1')).to.deep.eq({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 13082,
+    });
+  });
+
+  test('rejects a query string standing in for the repository', () => {
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos?x=/pull/9')).to.eq(undefined);
+  });
+
+  test('rejects a number the path continues through', () => {
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos/pull/13082x')).to.eq(undefined);
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos/pull/13082-old')).to.eq(undefined);
+  });
+
+  test('reads a URL copied out of prose, with its punctuation attached', () => {
+    for (const trailing of ['.', ',', ')', ']', '>']) {
+      expect(parsePullRequestUrl(`https://github.com/dxos/dxos/pull/13082${trailing}`)).to.deep.eq({
+        owner: 'dxos',
+        repo: 'dxos',
+        number: 13082,
+      });
+    }
+  });
+
+  test('ignores the case of the host', () => {
+    expect(parsePullRequestUrl('https://GitHub.com/dxos/dxos/pull/13082')).to.deep.eq({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 13082,
+    });
+  });
+
+  test('rejects anything that is not a pull request URL', () => {
+    expect(parsePullRequestUrl('https://github.com/dxos/dxos/issues/13082')).to.eq(undefined);
+    expect(parsePullRequestUrl('not a url')).to.eq(undefined);
+  });
+});

package/src/stories/github.ts

@@ -0,0 +1,70 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/** Owner, repository and number, as a pull request URL names them. */
+export type PullRequestRef = {
+  owner: string;
+  repo: string;
+  number: number;
+};
+
+// `[^/?#]`, and a word boundary after the number: an unanchored tail would read a query string as
+// part of the repository name and `…/pull/12x` as pull request 12, while a fixed delimiter set
+// would reject the trailing period or bracket a URL copied out of prose carries.
+const PULL_URL = /^https?:\/\/(?:www\.)?github\.com\/([^/?#]+)\/([^/?#]+)\/pull\/(\d+)(?![\w-])/i;
+
+/** Reads `https://github.com/owner/repo/pull/123`, with or without a trailing path. */
+export const parsePullRequestUrl = (url: string): PullRequestRef | undefined => {
+  const match = PULL_URL.exec(url.trim());
+  if (!match) {
+    return undefined;
+  }
+
+  return { owner: match[1], repo: match[2], number: Number(match[3]) };
+};
+
+export type RemotePullRequest = {
+  title: string;
+  body?: string;
+  baseBranch?: string;
+  headBranch?: string;
+  commit?: string;
+  diff: string;
+};
+
+const API = 'https://api.github.com';
+
+/**
+ * Fetches a public pull request and its diff straight from the browser. `api.github.com` answers
+ * cross-origin and does not require a token for a public repository, so a story needs no credentials
+ * — at the cost of the unauthenticated rate limit, which is per IP and easy to hit.
+ */
+export const fetchPullRequest = async ({ owner, repo, number }: PullRequestRef): Promise<RemotePullRequest> => {
+  const url = `${API}/repos/${owner}/${repo}/pulls/${number}`;
+  const [meta, diff] = await Promise.all([
+    fetch(url, { headers: { Accept: 'application/vnd.github+json' } }),
+    fetch(url, { headers: { Accept: 'application/vnd.github.v3.diff' } }),
+  ]);
+  if (!meta.ok) {
+    throw new Error(`GitHub answered ${meta.status} for ${owner}/${repo}#${number}.`);
+  }
+  if (!diff.ok) {
+    // 406 is how GitHub reports a pull request too large to serve as one diff.
+    throw new Error(
+      diff.status === 406
+        ? `${owner}/${repo}#${number} is too large for GitHub to serve as a single diff.`
+        : `GitHub answered ${diff.status} for the diff of ${owner}/${repo}#${number}.`,
+    );
+  }
+
+  const json = await meta.json();
+  return {
+    title: json.title,
+    body: json.body ?? undefined,
+    baseBranch: json.base?.ref,
+    headBranch: json.head?.ref,
+    commit: json.head?.sha,
+    diff: await diff.text(),
+  };
+};

package/src/stories/walkthrough-fixture.ts

@@ -0,0 +1,115 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/**
+ * A pull-request walkthrough: one markdown document whose prose, headings and ```diff fences read as
+ * a single narrative. Written out rather than generated so the story exercises the cases that matter
+ * visually — a pure insertion, a replacement, a removal, several hunks in one file, and a fence with
+ * no metadata at all.
+ */
+export const WALKTHROUGH = `# MCP latency probe
+
+Adds a latency probe to the assistant eval harness. One shared MCP connection serves a whole probe
+set: connect, list tools, warm up, then run timed iterations whose statistics the scorer reads
+instead of a thrown eval.
+
+## Harness wiring
+
+### Harness API surface
+
+\`ClaudeHarnessOptions.target\` plus harness fields for \`target\`, \`url\`, and a \`latency\` callback that
+dials the same surface the agent uses, on a separate connection.
+
+\`\`\`diff file=packages/core/compute/assistant-evals/src/claude-harness.ts lines=66-99 lang=typescript
+@@ -64,7 +66,16 @@ export type ClaudeHarnessOptions = {
+   allowedTools?: string[];
+   model?: string;
+   turnTimeout?: number;
++  /**
++   * Which MCP surface to drive: the in-process host, or one of the deployed
++   * \`mcp-space-service\` workers. Defaults to \`DX_EVAL_MCP_TARGET\`, and to
++   * \`local\` without it.
++   */
++  target?: McpTarget;
++
++  /** Called once per probe set with the measured connect and call latencies. */
++  latency?: (report: LatencyReport) => void;
+ };
+\`\`\`
+
+### Dial remote or host
+
+The dial is the only place that knows which surface is in play, so the rest of the harness keeps
+taking a client rather than a target.
+
+\`\`\`diff file=packages/core/compute/assistant-evals/src/claude-harness.ts lines=118-140 lang=typescript
+@@ -118,12 +120,16 @@ const connect = async (options: ClaudeHarnessOptions) => {
+-  const client = await createLocalClient(options);
+-  await client.connect();
+-  return client;
++  const target = options.target ?? (process.env.DX_EVAL_MCP_TARGET as McpTarget) ?? 'local';
++  const client = target === 'local' ? await createLocalClient(options) : await createRemoteClient(target);
++  await client.connect();
++  return client;
+ };
+\`\`\`
+
+## Probe runner
+
+One shared connection for the whole probe set: warmup, then timed iterations. Connect and listTools
+failures and per-call throws become errored samples; a cleanup failure must not discard a completed
+report.
+
+\`\`\`diff file=packages/core/compute/assistant-evals/src/McpLatency.ts lines=160-181 lang=typescript
+@@ -158,6 +160,24 @@ export const probe = async ({ target, probes, iterations }: ProbeOptions) => {
++    // The client may never have connected, and closing one that did not is not
++    // an error worth losing the report over.
++    connectMillis ??= Date.now() - connectStarted;
++    for (const probe of probes) {
++      samples.push({ tool: probe.tool, label: labelOf(probe), millis: Date.now() - connectStarted, isError: true });
++    }
++  } finally {
++    await client.close().catch(() => {});
++  }
++
++  return { target, url, connectMillis: connectMillis ?? 0, samples, stats: summarize(samples) };
+ };
+\`\`\`
+
+## Eval scenario
+
+### Scorers
+
+A failing probe is now a low score with a reason, not a thrown error, so one unreachable worker no
+longer voids the run.
+
+\`\`\`diff file=packages/core/compute/assistant-evals/src/mcp-server.eval.ts lines=40-58 lang=typescript
+@@ -40,9 +40,13 @@ const scorers = [
+   {
+     name: 'latency',
+-    score: ({ output }) => {
+-      throw new Error('not implemented');
+-    },
++    score: ({ output }) => ({
++      score: output.stats.p95 < BUDGET_MILLIS ? 1 : 0,
++      metadata: { p95: output.stats.p95, budget: BUDGET_MILLIS },
++    }),
+   },
+ ];
+\`\`\`
+
+## Documentation
+
+The README gains the environment variable and what the probe reports. A fence needs no metadata when
+the prose above it has already said which file is in play.
+
+\`\`\`diff
+@@ -12,3 +12,7 @@
+ Run the suite with \`moon run assistant-evals:test\`.
++
++Set \`DX_EVAL_MCP_TARGET\` to \`local\`, \`staging\` or \`production\` to choose the
++MCP surface the latency probe dials. The probe reports connect time, per-tool
++p50 and p95, and the error rate across the probe set.
+\`\`\`
+`;

package/src/testing/fixtures.ts

@@ -0,0 +1,99 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { random } from '@dxos/random';
+import { Issue, PullRequest, Repo } from '@dxos/types';
+
+import { type GitHubCapabilities } from '#types';
+
+import { type GitHubLink } from '../extensions/index.ts';
+
+// Kept out of the story modules: react-refresh only fast-refreshes a module whose exports are all
+// components, so factories exported beside a story force a full page reload on every edit.
+
+/** Deterministic per link, so a re-hover shows the same fixture. */
+const seedFor = (link: GitHubLink) =>
+  random.seed(link.url.split('').reduce((acc: number, char: string) => acc + char.charCodeAt(0), 1));
+
+/** A repository fixture for a link, deterministic per URL. */
+export const createRepo = (
+  link: GitHubLink = { owner: 'dxos', repo: 'dxos', kind: 'repo', url: 'https://github.com/dxos/dxos' },
+): Repo.Repo => {
+  seedFor(link);
+  return Repo.make({
+    owner: link.owner,
+    name: link.repo,
+    url: link.url,
+    description: random.lorem.paragraph(),
+    defaultBranch: 'main',
+  });
+};
+
+/** An issue fixture for a link, deterministic per URL. */
+export const createIssue = (
+  link: GitHubLink = {
+    owner: 'dxos',
+    repo: 'dxos',
+    kind: 'issue',
+    number: 1,
+    url: 'https://github.com/dxos/dxos/issues/1',
+  },
+): Issue.Issue => {
+  seedFor(link);
+  return Issue.make({
+    owner: link.owner,
+    repo: link.repo,
+    number: link.number ?? 0,
+    url: link.url,
+    title: random.lorem.sentence(),
+    state: random.helpers.arrayElement(['open', 'closed'] as const),
+    author: random.person.fullName(),
+    description: random.lorem.paragraph(),
+    labels: ['bug', 'editor'],
+  });
+};
+
+/** A pull-request fixture for a link, deterministic per URL. */
+export const createPullRequest = (
+  link: GitHubLink = {
+    owner: 'dxos',
+    repo: 'dxos',
+    kind: 'pull',
+    number: 13007,
+    url: 'https://github.com/dxos/dxos/pull/13007',
+  },
+): PullRequest.PullRequest => {
+  seedFor(link);
+  return PullRequest.make({
+    owner: link.owner,
+    repo: link.repo,
+    number: link.number ?? 0,
+    url: link.url,
+    title: random.lorem.sentence(),
+    state: random.helpers.arrayElement(['open', 'merged', 'draft', 'closed'] as const),
+    author: random.person.fullName(),
+    description: random.lorem.paragraph(),
+    baseBranch: 'main',
+    headBranch: `${random.lorem.word()}/${random.lorem.word()}`,
+    additions: random.number.int({ min: 5, max: 900 }),
+    deletions: random.number.int({ min: 0, max: 400 }),
+  });
+};
+
+/** A repository the fixture source cannot reach, standing in for a private one the space holds no token for. */
+export const UNREACHABLE_REPO = 'private';
+
+/** A `LinkSource` answering from fixtures, so a story exercises the resolver without the network. */
+export const fixtureLinkSource: GitHubCapabilities.GitHubLinkSource = (link) =>
+  Effect.succeed(
+    link.repo === UNREACHABLE_REPO
+      ? undefined
+      : link.kind === 'repo'
+        ? createRepo(link)
+        : link.kind === 'pull'
+          ? createPullRequest(link)
+          : createIssue(link),
+  );

package/src/testing/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './fixtures.ts';
+export * from './plugin.ts';
+export * from './pull-request-13348.ts';

package/src/testing/plugin.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Capability from '@dxos/app-framework/Capability';
+import * as Plugin from '@dxos/app-framework/Plugin';
+import { DXN } from '@dxos/keys';
+
+import { GitHubCapabilities } from '#types';
+
+import { fixtureLinkSource } from './fixtures.ts';
+
+/** Replaces the plugin's default fetch: a story answers every link from fixtures, deterministic per URL. */
+export const FixtureLinkSourcePlugin = Plugin.define(
+  Plugin.makeMeta({ key: DXN.make('org.dxos.plugin.github.testing.linkSource'), name: 'Fixture link source' }),
+).pipe(
+  Plugin.addModule({
+    id: 'linkSource',
+    provides: [GitHubCapabilities.LinkSource],
+    activate: () => Effect.succeed([Capability.contribute(GitHubCapabilities.LinkSource, fixtureLinkSource)]),
+  }),
+  Plugin.make,
+);