@taiga-ai/mcp-server 0.4.0 → 0.5.0-rc.389

package/src/tools/products.ts

@@ -1,106 +1,120 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { TaigaClient } from '../client.js';
+import { runTool, toolResult } from './errors.js';
+import { documentType } from './inputs.js';
 import { summarizeList } from './summarize.js';
 
+const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false } as const;
+
 export function registerProductTools(server: McpServer, client: TaigaClient) {
   if (client.hasCapability('factories:read')) {
-    server.tool(
+    server.registerTool(
       'taiga_list_factories',
-      'List all factories in the organization. A factory is the group that owns a set of products. ' +
-        'Use this to find factory IDs for reading factory instructions. ' +
-        "Factory instructions carry the factory's standing guidance: domain context, tech preferences, " +
-        'and the conventions its products follow.',
       {
-        limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        title: 'List factories',
+        description:
+          'List all factories in the organization. A factory is the group that owns a set of products. ' +
+          'Use this to find factory IDs for reading factory instructions. ' +
+          "Factory instructions carry the factory's standing guidance: domain context, tech preferences, " +
+          'and the conventions its products follow.',
+        inputSchema: {
+          limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        },
+        annotations: READ_ONLY,
       },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.listFactories(params);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-        };
-      }
+      (params) =>
+        runTool(async () => {
+          const result = await client.listFactories(params);
+          return toolResult(result.data);
+        })
     );
   }
 
   if (client.hasCapability('products:read')) {
-    server.tool(
+    server.registerTool(
       'taiga_list_products',
-      'List products in the organization. Use this to find the product you are working on ' +
-        'so you can read its specification, architecture, and threat model. ' +
-        'Can filter by factory; a status filter also exists but no longer distinguishes anything (see its description).',
       {
-        factoryId: z
-          .string()
-          .uuid()
-          .optional()
-          .describe('Filter by factory ID -- get factory IDs from taiga_list_factories'),
-        status: z
-          .enum(['draft', 'active', 'archived'])
-          .optional()
-          .describe(
-            'Filter by status. Taiga no longer surfaces product status in its UI (PRO-543), so every ' +
-              'product is currently "draft" and filtering by "active" or "archived" returns nothing. ' +
-              'Omit this unless you are working with data set through the API directly.'
-          ),
-        limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        title: 'List products',
+        description:
+          'List products in the organization. Use this to find the product you are working on ' +
+          'so you can read its specification, architecture, and threat model. ' +
+          'Can filter by factory; a status filter also exists but no longer distinguishes anything (see its description).',
+        inputSchema: {
+          factoryId: z
+            .string()
+            .uuid()
+            .optional()
+            .describe('Filter by factory ID -- get factory IDs from taiga_list_factories'),
+          status: z
+            .enum(['draft', 'active', 'archived'])
+            .optional()
+            .describe(
+              'Filter by status. Taiga no longer surfaces product status in its UI (PRO-543), so every ' +
+                'product is currently "draft" and filtering by "active" or "archived" returns nothing. ' +
+                'Omit this unless you are working with data set through the API directly.'
+            ),
+          limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        },
+        annotations: READ_ONLY,
       },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.listProducts(params);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-        };
-      }
+      (params) =>
+        runTool(async () => {
+          const result = await client.listProducts(params);
+          return toolResult(result.data);
+        })
     );
 
-    server.tool(
+    server.registerTool(
       'taiga_list_product_documents',
-      'List documents for a specific product (names and types only). ' +
-        'Product documents are generated during intake: specification (requirements), ' +
-        'architecture (system design), technology decisions, data flow, privacy assessment, ' +
-        'threat model (security risks), risk register, user flow, and service blueprint. ' +
-        'Use taiga_get_product_document to read the full content.',
       {
-        productId: z.string().uuid().describe('Product ID -- get from taiga_list_products'),
-        limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        title: 'List product documents',
+        description:
+          'List documents for a specific product (names and types only). ' +
+          'Product documents are generated during intake: specification (requirements), ' +
+          'architecture (system design), technology decisions, data flow, privacy assessment, ' +
+          'threat model (security risks), risk register, user flow, and service blueprint. ' +
+          'Use taiga_get_product_document to read the full content.',
+        inputSchema: {
+          productId: z.string().uuid().describe('Product ID -- get from taiga_list_products'),
+          limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
+        },
+        annotations: READ_ONLY,
       },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.listProductDocuments(params.productId, { limit: params.limit });
-        const summaries = summarizeList(result.data as Record<string, unknown>[]);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(summaries, null, 2) }],
-        };
-      }
+      (params) =>
+        runTool(async () => {
+          const result = await client.listProductDocuments(params.productId, { limit: params.limit });
+          const summaries = summarizeList(result.data as Record<string, unknown>[]);
+          return toolResult(summaries);
+        })
     );
 
-    server.tool(
+    server.registerTool(
       'taiga_get_product_document',
-      'Get the full content of a specific product document. ' +
-        'Use this when you need to understand what to build (specification), ' +
-        'how the system is designed (architecture), what security risks exist (threat model), ' +
-        'or what technology choices were made (technology_decisions). ' +
-        'Types: specification, architecture, technology_decisions, data_flow, ' +
-        'privacy_assessment, threat_model, risk_register, user_flow, service_blueprint, ' +
-        "ui_direction, codebase_snapshot, and product_instructions (the product's standing instructions).",
       {
-        productId: z.string().uuid().describe('Product ID -- get from taiga_list_products'),
-        type: z
-          .string()
-          .describe(
+        title: 'Get product document',
+        description:
+          'Get the full content of a specific product document. ' +
+          'Use this when you need to understand what to build (specification), ' +
+          'how the system is designed (architecture), what security risks exist (threat model), ' +
+          'or what technology choices were made (technology_decisions). ' +
+          'Types: specification, architecture, technology_decisions, data_flow, ' +
+          'privacy_assessment, threat_model, risk_register, user_flow, service_blueprint, ' +
+          "ui_direction, codebase_snapshot, and product_instructions (the product's standing instructions).",
+        inputSchema: {
+          productId: z.string().uuid().describe('Product ID -- get from taiga_list_products'),
+          type: documentType.describe(
             'Document type -- get available types from taiga_list_product_documents. ' +
               'Common: specification, architecture, threat_model, technology_decisions'
           ),
+        },
+        annotations: READ_ONLY,
       },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.getProductDocument(params.productId, params.type);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-        };
-      }
+      (params) =>
+        runTool(async () => {
+          const result = await client.getProductDocument(params.productId, params.type);
+          return toolResult(result.data);
+        })
     );
   }
 }

package/src/tools/sections.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { applySectionEdit, sectionContent, sectionsOf } from './sections.js';
+
+describe('sectionsOf', () => {
+  it('returns the sections map of a section-shaped document', () => {
+    expect(sectionsOf({ sections: { a: { content: 'x' } } })).toEqual({ a: { content: 'x' } });
+  });
+
+  it('returns null for documents that keep their content elsewhere', () => {
+    expect(sectionsOf({ components: {} })).toBeNull();
+    expect(sectionsOf({ sections: 'text' })).toBeNull();
+    expect(sectionsOf({ sections: ['a'] })).toBeNull();
+  });
+});
+
+describe('sectionContent', () => {
+  it('reads object and bare-string sections alike', () => {
+    expect(sectionContent({ a: { content: 'x' } }, 'a')).toBe('x');
+    expect(sectionContent({ a: 'plain' }, 'a')).toBe('plain');
+  });
+
+  it('is empty for a section without text and null for a missing or null one', () => {
+    expect(sectionContent({ a: { priority: 'core' } }, 'a')).toBe('');
+    expect(sectionContent({}, 'a')).toBeNull();
+    expect(sectionContent({ a: null }, 'a')).toBeNull();
+  });
+});
+
+describe('applySectionEdit', () => {
+  const sections = {
+    summary: { source: 'template', priority: 'core', content: 'old', derivedFrom: ['doc-1'] },
+    scope: 'bare string',
+    list: ['not', 'a', 'section'],
+  };
+
+  it('replaces the text and keeps the section metadata and the other sections', () => {
+    expect(applySectionEdit(sections, 'summary', 'new')).toEqual({
+      summary: { source: 'template', priority: 'core', content: 'new', derivedFrom: ['doc-1'] },
+      scope: 'bare string',
+      list: ['not', 'a', 'section'],
+    });
+  });
+
+  it('turns a bare-string or array-valued section into an object with the new text', () => {
+    expect(applySectionEdit(sections, 'scope', 'new').scope).toEqual({ content: 'new' });
+    expect(applySectionEdit(sections, 'list', 'new').list).toEqual({ content: 'new' });
+  });
+
+  it('adds a section that did not exist', () => {
+    expect(applySectionEdit(sections, 'retention', 'keep 90 days').retention).toEqual({ content: 'keep 90 days' });
+  });
+
+  it('does not mutate its input', () => {
+    applySectionEdit(sections, 'summary', 'new');
+
+    expect(sections.summary.content).toBe('old');
+  });
+});

package/src/tools/sections.ts

@@ -0,0 +1,38 @@
+/**
+ * How a section edit changes a document's `data`.
+ *
+ * Policies, organization instructions and factory instructions keep their
+ * content under `data.sections`, one entry per section id. An edit replaces
+ * that section's text and nothing else: `priority` (ordering), `source` and
+ * `derivedFrom` (which reference documents shaped it, PRO-2158) stay, so the
+ * next derivation does not re-add what an earlier one already brought in.
+ * Same rule as the web editor (apps/web/src/features/organization/lib/
+ * policySectionEdits.ts); the two must agree or a draft saved from one
+ * surface loses what the other preserved.
+ */
+
+/** A section as stored: an object with `content` and metadata, or (older rows) a bare string. */
+export type Sections = Record<string, unknown>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** The `sections` map of a document, or null when the document is not section-shaped. */
+export function sectionsOf(data: Record<string, unknown>): Sections | null {
+  return isRecord(data.sections) ? data.sections : null;
+}
+
+/** The text of one section, or null when the section does not exist. */
+export function sectionContent(sections: Sections, sectionId: string): string | null {
+  const section = sections[sectionId];
+  if (section === undefined || section === null) return null;
+  if (typeof section === 'string') return section;
+  return isRecord(section) && typeof section.content === 'string' ? section.content : '';
+}
+
+/** The map with one section's text replaced (or the section added); every other section untouched. */
+export function applySectionEdit(sections: Sections, sectionId: string, content: string): Sections {
+  const prior = sections[sectionId];
+  return { ...sections, [sectionId]: isRecord(prior) ? { ...prior, content } : { content } };
+}

package/tsconfig.json

@@ -1,18 +1,21 @@
 {
+  "extends": "@tsconfig/strictest/tsconfig.json",
   "compilerOptions": {
     "target": "ES2022",
     "module": "ESNext",
     "moduleResolution": "bundler",
     "declaration": true,
     "declarationMap": true,
-    "strict": true,
-    "skipLibCheck": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "esModuleInterop": true,
     "resolveJsonModule": true,
-    "types": ["node"]
+    "types": ["node"],
+
+    // Preset flags this package still fails (PRO-2509). Each line is deleted
+    // by the issue named beside it; no new line is added here.
+    "noPropertyAccessFromIndexSignature": false // PRO-2519
   },
   "include": ["src"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../../packages/types" }]
 }