@taiga-ai/mcp-server 0.25.0-rc.474 → 0.26.0-dev.479

package/src/tools/repositories.ts

@@ -1,360 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-import type { GithubRepository } from '@taiga/types';
-import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
-import { OPERATE, OPERATE_SETTING, READ_ONLY } from './annotations.js';
-import { isNetworkFailure, runTool, toolError, toolResult } from './errors.js';
-import { setupReadiness } from './readiness.js';
-import { idInput, pagination, productId } from './inputs.js';
-import { SEARCH_WITH_CURSOR, page, pickFields } from './summarize.js';
-
-/**
- * A product's repository (docs.tai.ga, Administration: Integrations and
- * environments, Source control). A linked repository is the prerequisite for
- * most of what Taiga does: planning reads the code, runs work on a branch of
- * it, sweeps scan it and the as-built documents are derived from it. GitHub is
- * connected once for the organization, in the web; linking one of the
- * repositories it can reach to a product is a separate act, per product.
- */
-
-const LINK_FIELDS = [
-  'id',
-  'provider',
-  'repositoryName',
-  'repositoryUrl',
-  'repositoryDefaultBranch',
-  'baseBranch',
-  'effectiveBranch',
-  'label',
-  'buildable',
-  'isManaged',
-] as const;
-
-const INSTALLATION_FIELDS = [
-  'id',
-  'accountLogin',
-  'accountType',
-  'repositorySelection',
-  'suspendedAt',
-  'lastSyncError',
-] as const;
-
-const GITHUB_REPOSITORY_FIELDS = [
-  'id',
-  'fullName',
-  'private',
-  'archived',
-  'defaultBranch',
-  'description',
-  'language',
-  // A product already links it (PRO-2800); absent from an API that predates the field.
-  'linked',
-  // Which product holds it, to a key that sees every product (PRO-2822).
-  'linkedProduct',
-] as const;
-
-const repositoryId = idInput(
-  'repository link',
-  'taiga_list_product_repositories gives it; a linkable repository id is not one'
-);
-
-/** Round-robin over lists: the first of each, then the second of each, and so on. */
-export function interleave<T>(lists: T[][]): T[] {
-  const out: T[] = [];
-  const longest = Math.max(0, ...lists.map((list) => list.length));
-  for (let index = 0; index < longest; index++) {
-    for (const list of lists) if (index < list.length) out.push(list[index]!);
-  }
-  return out;
-}
-
-/**
- * A repository linked elsewhere names the product that holds it (PRO-2800): the API says "another product", and a
- * reviewer spent a call finding which. One read, the products the key can see; null leaves the API's refusal.
- */
-async function holderOf(client: TaigaClient, error: unknown, productId: string) {
-  if (!(error instanceof TaigaApiError) || error.status !== 409) return null;
-  // An API that names the holder (PRO-2807) says it itself; an older one, or a key that cannot see every product,
-  // says "another product", and this lists the ones the key can see.
-  if (error.details?.['holder']) return null;
-  const name = /^(\S+\/\S+) is already linked to another product\./.exec(error.apiMessage ?? '')?.[1];
-  if (!name) return null;
-  try {
-    // The refusal names the repository only, not its host, and the same name can live on github.com and on an
-    // enterprise host: these are the products with a repository of that name, which is as exact as it can say.
-    const holders = (await client.listProducts({ repository: name, limit: 20 })).data.filter((p) => p.id !== productId);
-    const said =
-      holders.length > 0
-        ? `Products this key can see with a repository named ${name}: ${holders.map((p) => `${p.name} (${p.id})`).join(', ')}.`
-        : 'It is linked to a product this key cannot see.';
-    return toolError(
-      'CONFLICT',
-      `${name} is already linked to another product. ${said} A repository belongs to one product; unlink it there ` +
-        'first (taiga_unlink_repository) if this product should have it.',
-      { holders: holders.map((p) => ({ productId: p.id, name: p.name })) }
-    );
-  } catch (inner) {
-    if (inner instanceof TaigaApiError || isNetworkFailure(inner)) return null;
-    throw inner;
-  }
-}
-
-/**
- * A product in setup says what it still needs after a repository write, as create_product and get_product do
- * (PRO-2800): a reviewer had to read the product again to learn that the import came next. Best effort: the write
- * is done, so a failed read leaves readiness out rather than failing it.
- */
-async function readinessAfter(client: TaigaClient, productId: string): Promise<{ readiness?: unknown }> {
-  try {
-    const readiness = await setupReadiness(
-      client,
-      (await client.getProduct(productId)).data as unknown as Record<string, unknown>
-    );
-    return readiness ? { readiness } : {};
-  } catch (error) {
-    if (error instanceof TaigaApiError || isNetworkFailure(error)) return {};
-    throw error;
-  }
-}
-
-export function registerRepositoryTools(server: McpServer, client: TaigaClient) {
-  if (client.hasCapability('products:read')) {
-    server.registerTool(
-      'taiga_list_product_repositories',
-      {
-        title: "List a product's repositories",
-        description:
-          'List the repositories linked to a product, each with effectiveBranch (the chosen branch, or the ' +
-          "repository's default) and buildable (whether Taiga can plan and build in it).",
-        inputSchema: z.object({ productId }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          // The route answers one page of 100 and takes no cursor: past that, the list says it is cut.
-          const result = await client.listProductRepositories(params.productId);
-          return toolResult({
-            data: pickFields(result.data, LINK_FIELDS),
-            truncated: result.nextCursor !== null,
-          });
-        })
-    );
-
-    server.registerTool(
-      'taiga_list_repository_branches',
-      {
-        title: "List a repository's branches",
-        description:
-          "List the branches of a product's linked repository, each with whether it is protected, to choose the " +
-          'one Taiga works on (taiga_set_repository_branch). truncated: true means there are more than listed.',
-        inputSchema: z.object({ productId, repositoryId }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          const result = await client.listRepositoryBranches(params.productId, params.repositoryId);
-          return toolResult({ data: result.data, truncated: result.truncated });
-        })
-    );
-  }
-
-  if (client.hasCapability('vcs:read')) {
-    server.registerTool(
-      'taiga_list_linkable_repositories',
-      {
-        title: 'Find a repository to link',
-        description:
-          "List the repositories the organization's GitHub connection can reach, to link one with " +
-          "taiga_link_repository (it takes the row's id as linkableRepositoryId). query searches by name; account (login, owner, or " +
-          'installationId) reads one account, else rows come from every account in turn. linked: true means a ' +
-          'product already links it, and linkedProduct names it to a key that sees every product. No connection means GitHub is not ' +
-          'connected yet; someone who can install the app does that once, in the web.',
-        inputSchema: z.object({
-          query: z.string().trim().min(1).max(256).optional().describe('Part of the repository name'),
-          account: z
-            .string()
-            .trim()
-            .min(1)
-            // owner/repo: a 39-character login, the slash and a 100-character name.
-            .max(140)
-            .optional()
-            .describe('The GitHub account login (the owner in owner/repo), case-insensitive'),
-          installationId: idInput('GitHub account', 'this tool lists them').optional(),
-          ...pagination,
-        }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          const installations = (await client.listGithubInstallations()).data;
-          const accounts = pickFields(installations, INSTALLATION_FIELDS);
-          if (installations.length === 0) {
-            return toolError(
-              'NOT_CONNECTED',
-              'GitHub is not connected for this organization. It is connected once, in the web; then link.'
-            );
-          }
-          // owner/repo names the owner too: the part before the slash is the account.
-          const login = params.account?.split('/')[0]!.toLowerCase();
-          const chosen = installations.filter(
-            (i) =>
-              (!params.installationId || i.id === params.installationId) &&
-              (!login || String(i.accountLogin ?? '').toLowerCase() === login)
-          );
-          if (chosen.length === 0) {
-            return toolError('NOT_FOUND', 'No such GitHub connection; these are the connected accounts.', { accounts });
-          }
-          // A cursor belongs to one account's pages, and a search answers one
-          // ranked page: either way a cursor would quietly start over.
-          if (params.cursor !== undefined && params.query !== undefined) {
-            return toolError('VALIDATION_ERROR', SEARCH_WITH_CURSOR);
-          }
-          if (chosen.length > 1 && params.cursor !== undefined) {
-            return toolError('VALIDATION_ERROR', 'A cursor pages one account: name it (account or installationId).', {
-              accounts,
-            });
-          }
-          // `limit` is the most rows the answer carries, however many accounts
-          // are read: a search answers its ranked matches whatever the page
-          // size, and several accounts add up.
-          const max = params.limit ?? 25;
-          const rows = (data: WithoutTenant<GithubRepository>[]) => pickFields(data, GITHUB_REPOSITORY_FIELDS);
-          if (chosen.length === 1) {
-            const result = await client.listInstallationRepositories(String(chosen[0]!.id), {
-              q: params.query,
-              limit: max,
-              cursor: params.cursor,
-            });
-            const found = rows(result.data);
-            return toolResult({
-              // The account asked for, not every connected one (PRO-2800).
-              accounts: params.account || params.installationId ? pickFields(chosen, INSTALLATION_FIELDS) : accounts,
-              repositories: page(found.slice(0, max), result.nextCursor),
-              ...(found.length > max
-                ? { more: 'More matched than the limit; narrow the query or raise the limit.' }
-                : {}),
-            });
-          }
-          // Several accounts are read once each, as the web's picker reads them;
-          // a cursor belongs to one account, so the page has none.
-          const pages = await Promise.all(
-            chosen.map((i) => client.listInstallationRepositories(String(i.id), { q: params.query, limit: max }))
-          );
-          // In turn, one row from each account, so the first account's page
-          // cannot fill the answer and hide the others.
-          const perAccount = pages.map((p) => rows(p.data));
-          const found = interleave(perAccount);
-          const cut = found.length > max || pages.some((p) => p.nextCursor);
-          return toolResult({
-            accounts,
-            repositories: page(found.slice(0, max), null),
-            ...(cut ? { more: 'More than the limit across accounts: name an account, or narrow the query.' } : {}),
-          });
-        })
-    );
-  }
-
-  if (!client.hasCapability('vcs:manage')) return;
-
-  server.registerTool(
-    'taiga_link_repository',
-    {
-      title: 'Link a repository to a product',
-      description:
-        'Link a GitHub repository to a product (taiga_list_linkable_repositories gives its id). ' +
-        'replacesRepositoryId swaps out the one linked now in one step (the same one changes nothing); linking ' +
-        'while one is linked without it is refused. A managed link (isManaged) cannot be replaced or unlinked. ' +
-        'Once linked, planning reads its code, runs open pull requests in it, sweeps scan it, and its deployment ' +
-        'history is imported.',
-      inputSchema: z.object({
-        productId,
-        // Named for the list it comes from: it is Taiga's record of a repository the connection reaches, and three
-        // reviews read githubRepositoryId as GitHub's numeric id (PRO-2800).
-        linkableRepositoryId: idInput(
-          'linkable repository',
-          "taiga_list_linkable_repositories gives it (a row's id; not GitHub's numeric id, not a link ID)"
-        ),
-        replacesRepositoryId: repositoryId.optional().describe('The link this one replaces'),
-      }),
-      annotations: OPERATE,
-    },
-    (params) =>
-      runTool(async () => {
-        let linked;
-        try {
-          linked = await client.linkRepository(params.productId, {
-            githubRepositoryId: params.linkableRepositoryId,
-            ...(params.replacesRepositoryId ? { replacesRepositoryId: params.replacesRepositoryId } : {}),
-          });
-        } catch (error) {
-          const holder = await holderOf(client, error, params.productId);
-          if (holder) return holder;
-          throw error;
-        }
-        return toolResult({
-          ...pickFields([linked.data], LINK_FIELDS)[0],
-          ...(await readinessAfter(client, params.productId)),
-        });
-      })
-  );
-
-  server.registerTool(
-    'taiga_set_repository_branch',
-    {
-      title: 'Choose the branch Taiga works on',
-      description:
-        'Choose the branch Taiga branches from and opens pull requests against (taiga_list_repository_branches ' +
-        "lists them), or null for the repository's default. A protected branch is accepted, but Taiga may not be " +
-        'able to merge into it; the result says when it is protected. Optionally sets a label for the link.',
-      inputSchema: z.object({
-        productId,
-        repositoryId,
-        baseBranch: z
-          .string()
-          .trim()
-          .min(1)
-          .max(255)
-          .nullable()
-          .optional()
-          .describe('The branch; null for the default'),
-        label: z.string().trim().min(1).max(100).nullable().optional().describe('A label for the link; null clears it'),
-      }),
-      annotations: OPERATE_SETTING,
-    },
-    (params) =>
-      runTool(async () => {
-        if (params.baseBranch === undefined && params.label === undefined) {
-          return toolError('VALIDATION_ERROR', 'Set baseBranch, label or both.');
-        }
-        const updated = (
-          await client.updateRepository(params.productId, params.repositoryId, {
-            ...(params.baseBranch !== undefined ? { baseBranch: params.baseBranch } : {}),
-            ...(params.label !== undefined ? { label: params.label } : {}),
-          })
-        ).data;
-        return toolResult({
-          ...pickFields([updated], LINK_FIELDS)[0],
-          baseBranchProtection: updated.baseBranchProtection ?? null,
-          ...(await readinessAfter(client, params.productId)),
-        });
-      })
-  );
-
-  server.registerTool(
-    'taiga_unlink_repository',
-    {
-      title: 'Unlink a repository from a product',
-      description:
-        'Unlink a repository from a product. The product keeps its documents and initiatives, but nothing is ' +
-        'planned against code, built or swept. The repository itself is untouched; one Taiga created for the ' +
-        'product cannot be unlinked. To swap it, use taiga_link_repository with replacesRepositoryId.',
-      inputSchema: z.object({ productId, repositoryId }),
-      annotations: OPERATE,
-    },
-    (params) =>
-      runTool(async () => {
-        await client.unlinkRepository(params.productId, params.repositoryId);
-        return toolResult({ repositoryId: params.repositoryId, unlinked: true });
-      })
-  );
-}

package/src/tools/request-prompt.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { requestPrompt, stripInlineImages } from './request-prompt.js';
-
-const IMAGE = '![shot](/v1/custom-documents/0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5c/image)';
-
-describe('requestPrompt', () => {
-  it('joins the trimmed title and description with a blank line', () => {
-    expect(requestPrompt('  Add login ', ' Users log in.  ')).toBe('Add login\n\nUsers log in.');
-  });
-
-  it('is undefined when both are empty, which asks the agent for a suggestion', () => {
-    expect(requestPrompt('   ', '\n\n')).toBeUndefined();
-    expect(requestPrompt(undefined, undefined)).toBeUndefined();
-  });
-
-  it('drops inline images and collapses the blank lines they and the author left', () => {
-    expect(requestPrompt('T', `Before\n\n${IMAGE}\n\n\n\nAfter`)).toBe('T\n\nBefore\n\nAfter');
-  });
-});
-
-describe('stripInlineImages', () => {
-  it('keeps an image that is not a Taiga inline image, and a link to one that is not an image', () => {
-    const external = '![logo](https://example.com/logo.png)';
-    const download = '[file](/v1/custom-documents/0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5c/image)';
-    expect(stripInlineImages(`${external} ${download}`)).toBe(`${external} ${download}`);
-  });
-
-  it('does not take /imagefoo or /image/download for an inline image', () => {
-    const near = '![x](/v1/custom-documents/0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5c/image/download)';
-    expect(stripInlineImages(near)).toBe(near);
-  });
-});

package/src/tools/request-prompt.ts

@@ -1,28 +0,0 @@
-/**
- * The planner's prompt for an initiative request, built as the web builds it
- * (apps/web/src/features/loops/delivery/components/planning/generateBacklogJob.ts):
- * title and description trimmed, the description's inline-image markdown
- * removed and the blank lines it leaves collapsed, joined by a blank line.
- * The planner reads `userPrompt` and nothing else of the request, so the same
- * words must make the same prompt from either surface.
- *
- * The image pattern is the web's (inline-image-doc-ids.ts), which keeps it in
- * lockstep with the API's `extractInlineImageDocIds`: the `![...](...)` form,
- * an exact UUID, and a terminator after `/image`.
- */
-const INLINE_IMAGE_RE =
-  /!\[(?:[^\]\\]|\\.)*\]\([^)]*?\/custom-documents\/([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\/image(?=[)?#\s])[^)]*\)/g;
-
-/** The description without its inline images, as the web strips it. */
-export function stripInlineImages(markdown: string): string {
-  return markdown
-    .replace(INLINE_IMAGE_RE, '')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim();
-}
-
-/** The prompt for a title and a description; undefined when both are empty, which asks for a suggestion. */
-export function requestPrompt(title: string | undefined, description: string | undefined): string | undefined {
-  const body = stripInlineImages((description ?? '').trim());
-  return [(title ?? '').trim(), body].filter(Boolean).join('\n\n') || undefined;
-}

package/src/tools/resources.ts

@@ -1,217 +0,0 @@
-import {
-  type McpServer,
-  ProtocolError,
-  ProtocolErrorCode,
-  type ReadResourceResult,
-  ResourceTemplate,
-} from '@modelcontextprotocol/server';
-import { TaigaApiError, type TaigaClient } from '../client.js';
-import { apiFailureText, isMissOrRefusal } from './errors.js';
-import {
-  FACTORY_DOCUMENT_TYPES,
-  PRODUCT_DOCUMENT_ORIGINS,
-  PRODUCT_DOCUMENT_TYPES,
-  TENANT_DOCUMENT_TYPES,
-  defaultOriginFor,
-  productDocumentName,
-  type ProductDocumentOrigin,
-  type ProductDocumentType,
-} from './catalogue.js';
-import { productId as productIdInput } from './inputs.js';
-import { mimeTypeOf, renderDocument } from './markdown.js';
-import { stripProvenance } from './sections.js';
-
-/**
- * The knowledge base as resources, so an IDE can attach a document with `@`
- * the way it attaches a file. Every resource reads through the same routes
- * and capability gates as the tool that reads it, and returns the same
- * stripped content, rendered as Markdown where the document is a section
- * map. `resources/list` names what is published; the templates say how to
- * address the rest.
- *
- * A resource has no `isError` result: a refusal or a miss is a JSON-RPC
- * error, InvalidParams (the caller named something that does not exist)
- * with a message that says what does.
- */
-
-/** One text resource, rendered. */
-function contents(uri: string, doc: Record<string, unknown>): ReadResourceResult {
-  const rendered = renderDocument(stripProvenance(doc));
-  return { contents: [{ uri, mimeType: rendered.mimeType, text: rendered.text }] };
-}
-
-function invalid(message: string): never {
-  throw new ProtocolError(ProtocolErrorCode.InvalidParams, message);
-}
-
-function requireOneOf<T extends string>(what: string, value: string, allowed: readonly T[]): T {
-  if (!(allowed as readonly string[]).includes(value))
-    invalid(`${what} "${value}" is not one of: ${allowed.join(', ')}`);
-  return value as T;
-}
-
-function requireId(what: string, value: string): string {
-  if (!productIdInput.safeParse(value).success) invalid(`${what} "${value}" is not an ID`);
-  return value;
-}
-
-/** The read, with a miss or a refusal turned into guidance; anything else is the API failing and propagates. */
-async function served<T>(read: Promise<T>, miss: string): Promise<T> {
-  try {
-    return await read;
-  } catch (error) {
-    if (!isMissOrRefusal(error)) throw error;
-    return invalid(`${miss} (${apiFailureText(error)})`);
-  }
-}
-
-export function registerResources(server: McpServer, client: TaigaClient) {
-  if (client.hasCapability('tenant:documents:read')) {
-    const published = async () =>
-      (await client.listTenantDocuments({ limit: 100 })).data.filter((row) => row.isDraft === false);
-
-    server.registerResource(
-      'organization-document',
-      new ResourceTemplate('taiga://documents/{type}', {
-        // What is published, so the client can offer it without guessing.
-        // A tenant list the API would not serve must not empty every other
-        // resource from the client's picker: this one lists nothing then.
-        list: async () => ({
-          resources: (await published().catch(() => [])).map((row) => ({
-            uri: `taiga://documents/${String(row.type)}`,
-            name: String(row.name ?? row.type),
-            description: typeof row.description === 'string' ? row.description : undefined,
-            mimeType: mimeTypeOf(row),
-          })),
-        }),
-      }),
-      {
-        title: 'Organization document',
-        description:
-          'A published organization document: a policy, the business goals, the design or brand standards, the ' +
-          'tone of voice or the standing instructions. Sections rendered as headings.',
-      },
-      async (uri, variables) => {
-        const type = requireOneOf('Document type', String(variables['type']), TENANT_DOCUMENT_TYPES);
-        try {
-          return contents(uri.href, (await client.getTenantDocument(type)).data);
-        } catch (error) {
-          if (!isMissOrRefusal(error)) throw error;
-          // The follow-up list is best effort, but a failed one is said to
-          // have failed, not read as "nothing is published".
-          const rest = await published().then(
-            (rows) => {
-              const names = rows.map((row) => String(row.type));
-              return names.length > 0 ? `Published documents: ${names.join(', ')}.` : 'Nothing is published yet.';
-            },
-            (reason: unknown) =>
-              `The published list could not be read (${reason instanceof TaigaApiError ? apiFailureText(reason) : 'the request failed'}).`
-          );
-          return invalid(`No published ${type} the key can read (${apiFailureText(error)}). ${rest}`);
-        }
-      }
-    );
-  }
-
-  if (client.hasCapability('factories:read')) {
-    server.registerResource(
-      'factory-instructions',
-      new ResourceTemplate('taiga://factories/{factoryId}/instructions', { list: undefined }),
-      {
-        title: 'Factory instructions',
-        description:
-          "A factory's published standing guidance; taiga_list_factories gives the factory ID. Markdown for a " +
-          'section map, JSON otherwise (the read says which).',
-      },
-      async (uri, variables) => {
-        const factoryId = requireId('Factory ID', String(variables['factoryId']));
-        const doc = await served(
-          client.getFactoryDocument(factoryId, FACTORY_DOCUMENT_TYPES[0]),
-          'This factory has not published instructions, or the key cannot see the factory'
-        );
-        return contents(uri.href, doc.data);
-      }
-    );
-  }
-
-  if (client.hasCapability('products:read')) {
-    const documentType = (value: string): ProductDocumentType => {
-      if (value.includes('?')) invalid(`Name the timeline as ?origin=plan or ?origin=reality, not "${value}"`);
-      return requireOneOf('Document type', value, PRODUCT_DOCUMENT_TYPES);
-    };
-    const read = async (uri: URL, productId: string, type: ProductDocumentType, origin: ProductDocumentOrigin) => {
-      const result = await served(
-        client.getProductDocument(productId, type, origin),
-        `No published ${origin} ${type} for this product, or the key cannot see it; taiga_get_product_document without type shows what exists`
-      );
-      return contents(uri.href, { name: productDocumentName(type), ...result.data });
-    };
-
-    // The timeline template first: the SDK tries templates in registration
-    // order, and a URI with ?origin= would otherwise bind the query into {type}.
-    server.registerResource(
-      'product-document-on-timeline',
-      new ResourceTemplate('taiga://products/{productId}/documents/{type}{?origin}', { list: undefined }),
-      {
-        title: 'Product document on a timeline',
-        description:
-          'A product document from the named timeline: origin=plan (discovery) or origin=reality (derived from the code). ' +
-          'Markdown for a section map, JSON otherwise (the read says which).',
-      },
-      async (uri, variables) => {
-        const productId = requireId('Product ID', String(variables['productId']));
-        const type = documentType(String(variables['type']));
-        const origin = requireOneOf('Origin', String(variables['origin']), PRODUCT_DOCUMENT_ORIGINS);
-        return read(uri, productId, type, origin);
-      }
-    );
-
-    server.registerResource(
-      'product-document',
-      new ResourceTemplate('taiga://products/{productId}/documents/{type}', { list: undefined }),
-      {
-        title: 'Product document',
-        description:
-          "A product document from the product's own timeline (reality for an imported product, plan otherwise; " +
-          'the documents a person writes are always on the plan side). taiga_get_product_document without type shows what ' +
-          'exists; add ?origin=plan or ?origin=reality to read the other side. Markdown for a section map, JSON ' +
-          'otherwise (the read says which).',
-      },
-      async (uri, variables) => {
-        const productId = requireId('Product ID', String(variables['productId']));
-        const type = documentType(String(variables['type']));
-        const product = (
-          await served(
-            client.getProduct(productId),
-            'No product with that ID the key can see; taiga_list_products shows them'
-          )
-        ).data;
-        return read(uri, productId, type, defaultOriginFor(product, type));
-      }
-    );
-  }
-
-  if (client.hasCapability('backlog:read')) {
-    server.registerResource(
-      'backlog-item',
-      new ResourceTemplate('taiga://initiatives/{initiativeId}', { list: undefined }),
-      {
-        title: 'Initiative',
-        description:
-          'An initiative in full: description, acceptance criteria, technical context. taiga_list_initiatives ' +
-          'gives the item ID.',
-        mimeType: 'application/json',
-      },
-      async (uri, variables) => {
-        const initiativeId = requireId('Initiative ID', String(variables['initiativeId']));
-        const item = (
-          await served(
-            client.getBacklogItem(initiativeId),
-            'No initiative with that ID the key can see; taiga_list_initiatives shows what exists'
-          )
-        ).data;
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(item, null, 2) }] };
-      }
-    );
-  }
-}