@taiga-ai/mcp-server 0.24.0-rc.462 → 0.25.0-dev.465

package/src/tools/products.ts

@@ -279,7 +279,7 @@ export async function resolveProductRef(
       return refusal(
         apiFailureCode(error),
         error instanceof TaigaApiError && error.status === 404
-          ? 'No product with that ID the key can see; taiga_list_products shows the ones it can.'
+          ? 'No product with that ID the key can see. taiga_list_products (query finds one by name) shows the ones it can; a slug or git remote URL names one too.'
           : `No product with that ID the key can see (${apiFailureText(error)}); taiga_list_products shows the ones it can.`
       );
     }
@@ -470,41 +470,23 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
         })
     );
 
-    server.registerTool(
-      'taiga_list_product_documents',
-      {
-        title: 'List product documents',
-        description:
-          "List a product's documents on both timelines (type, name, version, draft state, review and update " +
-          `times); defaultOrigin is the product's own. ${ORIGIN_MEANING.plan} ${ORIGIN_MEANING.reality} ` +
-          'An empty side says why; an unlisted side is null with a note. ' +
-          'taiga_get_product_document reads one.',
-        inputSchema: z.object({ productId }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          // `unlistable` is how a miss message is built; the list says the
-          // same in its notes and a null side.
-          const { unlistable: _unlistable, ...timelines } = await documentTimelines(client, params.productId);
-          return toolResult(timelines);
-        })
-    );
-
     server.registerTool(
       'taiga_get_product_document',
       {
         title: 'Get product document',
         description:
-          'Read one product document from one timeline: plan (specification, architecture, threat_model, ' +
-          'technology_decisions) says what to build; reality says what the code does, so read it before changing ' +
-          "code. Omit origin for the product's own timeline. sections: [] returns the outline (ids, sizes); then " +
-          'name the sections you need (unknownSections names missing ids). A miss says which documents exist.',
+          'Read one product document from one timeline, or without type list both timelines (type, version, ' +
+          "draft and review state; defaultOrigin is the product's own; an empty side says why). plan " +
+          '(specification, architecture, threat_model, technology_decisions) says what to build; reality says ' +
+          "what the code does, so read it before changing code. Omit origin for the product's own timeline. " +
+          'sections: [] returns the outline (ids, sizes); then name the sections you need (unknownSections names ' +
+          'missing ids). A miss says which documents exist.',
         inputSchema: z.object({
           productId,
           type: z
             .enum(PRODUCT_DOCUMENT_TYPES)
-            .describe('Document type -- taiga_list_product_documents shows which ones the product has'),
+            .optional()
+            .describe('Document type; omit to list what the product has on both timelines'),
           origin: originInput,
           sections: sectionsInput,
         }),
@@ -512,16 +494,25 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
       },
       (params) =>
         runTool(async () => {
+          // Without a type, the list of both timelines (PRO-2800): one tool where a list tool stood beside it.
+          if (params.type === undefined) {
+            if (params.sections || params.origin) {
+              return toolError('VALIDATION_ERROR', 'Name the document (type) to read one timeline or its sections.');
+            }
+            const { unlistable: _unlistable, ...timelines } = await documentTimelines(client, params.productId);
+            return toolResult(timelines);
+          }
+          const type = params.type;
           // The product's own timeline when none is asked for; the API's
           // default is plan, which is the wrong side of an imported product.
           let product: ProductSettingsView | undefined;
           if (!params.origin) product = (await client.getProduct(params.productId)).data;
-          const origin = params.origin ?? defaultOriginFor(product, params.type);
+          const origin = params.origin ?? defaultOriginFor(product, type);
           try {
-            const result = await client.getProductDocument(params.productId, params.type, origin);
+            const result = await client.getProductDocument(params.productId, type, origin);
             const doc = stripProvenance(result.data);
             if (!params.sections) return toolResult(doc);
-            return sectionReadResult(doc, params.sections, `${origin} ${params.type}`);
+            return sectionReadResult(doc, params.sections, `${origin} ${type}`);
           } catch (error) {
             if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
             // A product the key cannot see is a product miss, not a document
@@ -530,7 +521,7 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
             // propagates, as the API failing.
             product ??= (await client.getProduct(params.productId)).data;
             const timelines = await documentTimelines(client, params.productId, product);
-            return toolError('NOT_FOUND', describeMiss(params.type, origin, timelines, product));
+            return toolError('NOT_FOUND', describeMiss(type, origin, timelines, product));
           }
         })
     );

package/src/tools/prompts.ts

@@ -148,7 +148,7 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
           architecture.status === 'fulfilled'
             ? fenced('markdown', renderDocument(stripProvenance(architecture.value.data)).text)
             : isNotFound(architecture.reason)
-              ? `(No published ${origin} architecture; taiga_list_product_documents shows what exists.)`
+              ? `(No published ${origin} architecture; taiga_get_product_document without type shows what exists.)`
               : unreadable('The architecture', architecture.reason);
         const instructionsText_ =
           instructions.status === 'fulfilled'

package/src/tools/readiness.ts

@@ -144,10 +144,10 @@ function nextStepFor(state: {
         if (state.missing && state.missing.length > 0) {
           return (
             `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? 'is' : 'are'} not ` +
-            'published: taiga_list_product_documents shows them, taiga_publish_product_document publishes a draft.'
+            'published: taiga_get_product_document without type shows them, taiga_publish_product_document publishes a draft.'
           );
         }
-        return `The import is done: review the reality documents (taiga_list_product_documents), then ${finish}`;
+        return `The import is done: review the reality documents (taiga_get_product_document without type), then ${finish}`;
       default:
         return 'taiga_start_import derives the documents from the code and runs by itself (paid agent work: ask first).';
     }

package/src/tools/repositories.ts

@@ -49,6 +49,8 @@ const GITHUB_REPOSITORY_FIELDS = [
   '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(
@@ -72,7 +74,10 @@ export function interleave<T>(lists: T[][]): T[] {
  */
 async function holderOf(client: TaigaClient, error: unknown, productId: string) {
   if (!(error instanceof TaigaApiError) || error.status !== 409) return null;
-  const name = /^(\S+\/\S+) is already linked to another product\.?$/.exec(error.apiMessage ?? '')?.[1];
+  // 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
@@ -162,7 +167,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
           "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 (taiga_get_product with its URL says which). No connection means GitHub is not ' +
+          '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'),

package/src/tools/resources.ts

@@ -142,7 +142,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
     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_list_product_documents shows what exists`
+        `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 });
     };
@@ -173,7 +173,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
         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_list_product_documents shows what ' +
+          '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).',
       },

package/src/tools/sections.ts

@@ -272,7 +272,7 @@ export function sectionReadResult(
     ? {
         note: policy
           ? `${asControl} is a control of ${policy}: read it with taiga_get_document (type: ${policy}, sections: ["${asControl}"]).`
-          : `${asControl} looks like a policy control id, which only a policy resolves: taiga_list_documents lists them.`,
+          : `${asControl} looks like a policy control id, which only a policy resolves: taiga_get_document without type lists them.`,
       }
     : {};
   if (known.length === 0) {