@taiga-ai/mcp-server 0.2.3-dev.255 → 0.2.3-dev.59

package/dist/server.integration.test.js

@@ -1,358 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import { TaigaClient } from './client.js';
-import { registerAllTools } from './tools/index.js';
-// ---------------------------------------------------------------------------
-// Helpers -- thin wrappers, not abstraction layers
-// ---------------------------------------------------------------------------
-/** All capabilities the MCP server understands. */
-const ALL_CAPABILITIES = [
-    'projects:read',
-    'teams:read',
-    'tenant:documents:read',
-    'tenant:documents:write',
-    'backlog:read',
-];
-/** All tool names the server can register (sorted for deterministic comparison). */
-const ALL_TOOL_NAMES = [
-    'taiga_get_document',
-    'taiga_get_project_document',
-    'taiga_get_skill',
-    'taiga_get_team_document',
-    'taiga_list_documents',
-    'taiga_list_project_documents',
-    'taiga_list_projects',
-    'taiga_list_skills',
-    'taiga_list_team_documents',
-    'taiga_list_teams',
-    'taiga_update_document',
-    'taiga_update_skill',
-    'taiga_update_team_document',
-];
-function makeFetchRouter(routes) {
-    return vi.fn().mockImplementation(async (url, init) => {
-        const path = new URL(url).pathname;
-        const method = init?.method ?? 'GET';
-        const key = `${method} ${path}`;
-        const body = routes[key] ?? routes[path];
-        if (body !== undefined) {
-            return {
-                ok: true,
-                status: 200,
-                json: () => Promise.resolve(body),
-                text: () => Promise.resolve(JSON.stringify(body)),
-            };
-        }
-        return {
-            ok: false,
-            status: 404,
-            json: () => Promise.resolve({ error: 'Not found' }),
-            text: () => Promise.resolve('Not found'),
-        };
-    });
-}
-function introspectionResponse(capabilities) {
-    return {
-        data: {
-            userId: 'user-1',
-            tenantId: 'tenant-1',
-            email: 'dev@test.com',
-            role: 'member',
-            capabilities,
-        },
-    };
-}
-/**
- * Boots a full MCP Client <-> Server pair connected in-memory.
- * The TaigaClient uses a route-based fetch mock, so no real HTTP is needed.
- * Returns both the MCP client (for protocol calls) and the fetch spy (for
- * verifying outgoing HTTP requests when needed).
- */
-async function bootMcpPair(opts) {
-    const allRoutes = {
-        '/v1/auth/introspect': introspectionResponse(opts.capabilities),
-        ...opts.routes,
-    };
-    const fetchSpy = makeFetchRouter(allRoutes);
-    vi.stubGlobal('fetch', fetchSpy);
-    // Arrange -- Taiga client, introspect, register tools
-    const taigaClient = new TaigaClient({
-        baseUrl: 'https://api.test.com',
-        apiKey: 'taiga_sk_live_test',
-    });
-    await taigaClient.introspect();
-    const server = new McpServer({ name: 'taiga-test', version: '0.0.1' });
-    registerAllTools(server, taigaClient);
-    const client = new Client({ name: 'test-client', version: '0.0.1' });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
-    return { client, fetchSpy };
-}
-/** Extract sorted tool names from a listTools response. */
-function toolNames(tools) {
-    return tools.map((t) => t.name).sort();
-}
-/** Extract parsed JSON from the first text content block of a tool call result. */
-function parseToolResult(result) {
-    const content = result.content;
-    return JSON.parse(content[0].text);
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe('MCP server integration', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    // -------------------------------------------------------------------------
-    // Tool discovery -- the AI assistant asks "what tools do you have?"
-    // These tests verify the server exposes exactly the right tools based on
-    // the API key's capabilities. This is the primary security contract.
-    // -------------------------------------------------------------------------
-    describe('tool discovery', () => {
-        it('should expose all 13 tools when API key has full capabilities', async () => {
-            const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
-            const { tools } = await client.listTools();
-            expect(toolNames(tools)).toEqual(ALL_TOOL_NAMES);
-        });
-        it('should reject tools/list when API key has no capabilities', async () => {
-            // When zero tools are registered, the MCP SDK doesn't advertise
-            // the tools capability at all -- the protocol-correct response
-            // is "Method not found".
-            const { client } = await bootMcpPair({ capabilities: [] });
-            await expect(client.listTools()).rejects.toThrow(/Method not found/);
-        });
-        it('should expose only team tools for a teams:read-only key', async () => {
-            const { client } = await bootMcpPair({ capabilities: ['teams:read'] });
-            const { tools } = await client.listTools();
-            const names = toolNames(tools);
-            expect(names).toContain('taiga_list_teams');
-            expect(names).toContain('taiga_list_team_documents');
-            expect(names).toContain('taiga_get_team_document');
-            expect(names).not.toContain('taiga_list_documents');
-            expect(names).not.toContain('taiga_update_document');
-        });
-        it('should expose read-only document tools without write capability', async () => {
-            const { client } = await bootMcpPair({ capabilities: ['tenant:documents:read'] });
-            const { tools } = await client.listTools();
-            const names = toolNames(tools);
-            expect(names).toContain('taiga_list_documents');
-            expect(names).toContain('taiga_get_document');
-            expect(names).toContain('taiga_list_skills');
-            expect(names).toContain('taiga_get_skill');
-            expect(names).not.toContain('taiga_update_document');
-        });
-        it('should expose write tools when documents:write is also granted', async () => {
-            const { client } = await bootMcpPair({
-                capabilities: ['tenant:documents:read', 'tenant:documents:write'],
-            });
-            const { tools } = await client.listTools();
-            const names = toolNames(tools);
-            expect(names).toContain('taiga_update_document');
-            expect(names).toContain('taiga_update_skill');
-        });
-        it('should expose team document write when both teams:read and documents:write are granted', async () => {
-            const { client } = await bootMcpPair({
-                capabilities: ['teams:read', 'tenant:documents:write'],
-            });
-            const { tools } = await client.listTools();
-            const names = toolNames(tools);
-            expect(names).toContain('taiga_update_team_document');
-            expect(names).toContain('taiga_list_teams');
-        });
-        it('should combine capabilities additively', async () => {
-            const { client } = await bootMcpPair({
-                capabilities: ['teams:read', 'tenant:documents:read'],
-            });
-            const { tools } = await client.listTools();
-            const names = toolNames(tools);
-            // teams:read tools present
-            expect(names).toContain('taiga_list_teams');
-            expect(names).toContain('taiga_list_team_documents');
-            // tenant:documents:read tools present
-            expect(names).toContain('taiga_list_documents');
-            expect(names).toContain('taiga_list_skills');
-            // write tools absent
-            expect(names).not.toContain('taiga_update_document');
-            expect(names).not.toContain('taiga_update_skill');
-        });
-        it('should provide a description and input schema for every tool', async () => {
-            const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
-            const { tools } = await client.listTools();
-            for (const tool of tools) {
-                expect(tool.description, `${tool.name} missing description`).toBeTruthy();
-                expect(tool.inputSchema, `${tool.name} missing inputSchema`).toBeDefined();
-                expect(tool.inputSchema.type).toBe('object');
-            }
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Capability-tool contract -- parametric tests proving each capability
-    // maps to exactly the right set of tools. If someone adds a tool but
-    // forgets the capability check, these tests catch it.
-    // -------------------------------------------------------------------------
-    describe('capability-tool contract', () => {
-        const CONTRACT = {
-            'projects:read': ['taiga_list_projects', 'taiga_list_project_documents', 'taiga_get_project_document'],
-            'teams:read': ['taiga_list_teams', 'taiga_list_team_documents', 'taiga_get_team_document'],
-            'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document', 'taiga_list_skills', 'taiga_get_skill'],
-            'tenant:documents:write': ['taiga_update_document', 'taiga_update_skill'],
-        };
-        for (const [capability, expectedTools] of Object.entries(CONTRACT)) {
-            it(`${capability} should gate: ${expectedTools.join(', ')}`, async () => {
-                const { client } = await bootMcpPair({ capabilities: [capability] });
-                const { tools } = await client.listTools();
-                const names = toolNames(tools);
-                for (const expected of expectedTools) {
-                    expect(names, `Expected ${expected} for ${capability}`).toContain(expected);
-                }
-            });
-        }
-    });
-    // -------------------------------------------------------------------------
-    // Tool execution -- the AI assistant calls a tool and gets data back.
-    // These test the full round-trip: MCP call -> tool handler -> TaigaClient
-    // -> (mocked) API -> response back through MCP protocol.
-    // -------------------------------------------------------------------------
-    describe('tool execution', () => {
-        it('should return team list as JSON text content', async () => {
-            const teams = [
-                { id: 't1', name: 'Product' },
-                { id: 't2', name: 'Platform' },
-            ];
-            const { client } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { 'GET /v1/teams': { data: teams, nextCursor: null } },
-            });
-            const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
-            expect(result.content).toHaveLength(1);
-            expect(parseToolResult(result)).toEqual(teams);
-        });
-        it('should send PATCH when updating a skill', async () => {
-            const skillId = '00000000-0000-0000-0000-000000000001';
-            const updated = { id: skillId, name: 'Updated Skill', content: '# Updated' };
-            const { client, fetchSpy } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { [`PATCH /v1/agent-skills/${skillId}`]: { data: updated } },
-            });
-            await client.callTool({
-                name: 'taiga_update_skill',
-                arguments: { id: skillId, content: '# Updated' },
-            });
-            const patchCall = fetchSpy.mock.calls.find((c) => c[1]?.method === 'PATCH');
-            expect(patchCall).toBeDefined();
-            expect(patchCall[0]).toContain(`/v1/agent-skills/${skillId}`);
-        });
-        it('should return document content through MCP protocol', async () => {
-            const docs = [{ id: 'd1', title: 'Security Policy' }];
-            const { client } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { 'GET /v1/tenants/current/documents': { data: docs, nextCursor: null } },
-            });
-            const result = await client.callTool({ name: 'taiga_list_documents', arguments: {} });
-            expect(parseToolResult(result)).toEqual(docs);
-        });
-        it('should send PUT when updating a document draft', async () => {
-            const docType = 'security_policy';
-            const updated = { type: docType, title: 'Updated Policy' };
-            const { client, fetchSpy } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { [`PUT /v1/tenants/current/documents/${docType}/draft`]: { data: updated } },
-            });
-            await client.callTool({
-                name: 'taiga_update_document',
-                arguments: { type: docType, data: { title: 'Updated' } },
-            });
-            const putCall = fetchSpy.mock.calls.find((c) => c[1]?.method === 'PUT');
-            expect(putCall).toBeDefined();
-            expect(putCall[0]).toContain(`/v1/tenants/current/documents/${docType}/draft`);
-        });
-        it('should send PUT when updating a team document draft', async () => {
-            const teamId = '00000000-0000-0000-0000-000000000001';
-            const docType = 'domain_context';
-            const updated = { type: docType, name: 'Domain Context' };
-            const { client, fetchSpy } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { [`PUT /v1/teams/${teamId}/documents/${docType}/draft`]: { data: updated } },
-            });
-            await client.callTool({
-                name: 'taiga_update_team_document',
-                arguments: { teamId, type: docType, data: { sections: { overview: 'Updated' } } },
-            });
-            const putCall = fetchSpy.mock.calls.find((c) => c[1]?.method === 'PUT' && c[0].includes('/teams/'));
-            expect(putCall).toBeDefined();
-            expect(putCall[0]).toContain(`/v1/teams/${teamId}/documents/${docType}/draft`);
-        });
-        it('should return skills through MCP protocol', async () => {
-            const skills = [{ id: 's1', name: 'React Standards' }];
-            const { client } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { 'GET /v1/agent-skills': { data: skills, nextCursor: null } },
-            });
-            const result = await client.callTool({ name: 'taiga_list_skills', arguments: {} });
-            expect(parseToolResult(result)).toEqual(skills);
-        });
-        it('should return teams through MCP protocol', async () => {
-            const teams = [{ id: 't1', name: 'Engineering' }];
-            const { client } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: { 'GET /v1/teams': { data: teams, nextCursor: null } },
-            });
-            const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
-            expect(parseToolResult(result)).toEqual(teams);
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Error handling -- when the API fails, the AI assistant should get a
-    // clear error, not a silent success or cryptic crash.
-    // -------------------------------------------------------------------------
-    describe('error handling', () => {
-        it('should surface API errors as MCP error content', async () => {
-            // Introspect succeeds, but all other endpoints fail
-            const fetchSpy = vi.fn().mockImplementation(async (url) => {
-                const path = new URL(url).pathname;
-                if (path === '/v1/auth/introspect') {
-                    return {
-                        ok: true,
-                        status: 200,
-                        json: () => Promise.resolve(introspectionResponse(ALL_CAPABILITIES)),
-                        text: () => Promise.resolve(''),
-                    };
-                }
-                return {
-                    ok: false,
-                    status: 500,
-                    json: () => Promise.resolve({ error: 'Internal Server Error' }),
-                    text: () => Promise.resolve('Internal Server Error'),
-                };
-            });
-            vi.stubGlobal('fetch', fetchSpy);
-            // Arrange
-            const taigaClient = new TaigaClient({ baseUrl: 'https://api.test.com', apiKey: 'test' });
-            await taigaClient.introspect();
-            const server = new McpServer({ name: 'test', version: '0.0.1' });
-            registerAllTools(server, taigaClient);
-            const mcpClient = new Client({ name: 'test-client', version: '0.0.1' });
-            const [ct, st] = InMemoryTransport.createLinkedPair();
-            await Promise.all([server.connect(st), mcpClient.connect(ct)]);
-            // Act
-            const result = await mcpClient.callTool({ name: 'taiga_list_projects', arguments: {} });
-            // Assert -- the MCP SDK marks tool errors with isError
-            expect(result.isError).toBe(true);
-        });
-        it('should reject tool calls with invalid parameters', async () => {
-            const { client } = await bootMcpPair({
-                capabilities: ALL_CAPABILITIES,
-                routes: {},
-            });
-            // taiga_get_project requires a UUID, not a plain string
-            const result = await client.callTool({
-                name: 'taiga_get_project',
-                arguments: { id: 'not-a-uuid' },
-            });
-            expect(result.isError).toBe(true);
-        });
-    });
-});

package/dist/tools/backlogs.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { TaigaClient } from '../client.js';
-export declare function registerBacklogTools(_server: McpServer, _client: TaigaClient): void;
-//# sourceMappingURL=backlogs.d.ts.map

package/dist/tools/backlogs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backlogs.d.ts","sourceRoot":"","sources":["../../src/tools/backlogs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,QAG5E"}

package/dist/tools/backlogs.js

@@ -1,6 +0,0 @@
-// Backlog tools are reserved for post-beta.
-// The beta MCP server focuses on the knowledge base (policies, skills, team docs).
-export function registerBacklogTools(_server, _client) {
-    // No backlog tools in beta -- will be added when the MCP server
-    // expands beyond the knowledge base use case.
-}

package/dist/tools/documents.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { TaigaClient } from '../client.js';
-export declare function registerDocumentTools(server: McpServer, client: TaigaClient): void;
-//# sourceMappingURL=documents.d.ts.map

package/dist/tools/documents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../src/tools/documents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,QA6I3E"}

package/dist/tools/documents.js

@@ -1,97 +0,0 @@
-import { z } from 'zod';
-import { summarizeList } from './summarize.js';
-export function registerDocumentTools(server, client) {
-    // ── Company-level policy documents ──────────────────────────────────
-    if (client.hasCapability('tenant:documents:read')) {
-        server.tool('taiga_list_documents', 'List company-level policy documents (names and types only). ' +
-            'Policies define security, data privacy, SDLC, operations, architecture, and compliance rules ' +
-            'that apply across all teams and projects. ' +
-            'Use taiga_get_document with the document type to read the full policy content.', {
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listTenantDocuments(params);
-            const summaries = summarizeList(result.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }],
-            };
-        });
-        server.tool('taiga_get_document', 'Get the full content of a company policy document. ' +
-            'Use this when you need to understand security requirements, data handling rules, ' +
-            'architecture standards, or compliance controls that apply to your code. ' +
-            'Types: policy_security, policy_data, policy_sdlc, policy_ops, policy_tic, ' +
-            'policy_risk, policy_architecture, policy_supply_chain, policy_acceptable_use, policy_ip.', {
-            type: z
-                .string()
-                .describe('Document type -- get available types from taiga_list_documents. ' +
-                'Common: policy_security, policy_data, policy_sdlc, policy_architecture'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.getTenantDocument(params.type);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-    if (client.hasCapability('tenant:documents:write')) {
-        server.tool('taiga_update_document', 'Update the draft content of a company policy document. ' +
-            'Only updates the draft -- does not publish. Use this when you notice a policy ' +
-            'is outdated or needs corrections while reviewing code.', {
-            type: z.string().describe('Document type (e.g. policy_security, policy_sdlc)'),
-            data: z.record(z.string(), z.unknown()).describe('Document content to save as JSON'),
-        }, { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async (params) => {
-            const { type, ...body } = params;
-            const result = await client.saveTenantDocumentDraft(type, body);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-    // ── Team documents ──────────────────────────────────────────────────
-    if (client.hasCapability('teams:read')) {
-        server.tool('taiga_list_team_documents', 'List documents for a specific team (names and types only). ' +
-            'Team documents define how the team works: domain context (entities, ubiquitous language), ' +
-            'tech preferences (approved stack), architecture constraints, SLO targets, ' +
-            'definition of done, and team charter. ' +
-            'Use taiga_get_team_document to read the full content.', {
-            teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listTeamDocuments(params.teamId, { limit: params.limit });
-            const summaries = summarizeList(result.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }],
-            };
-        });
-        server.tool('taiga_get_team_document', 'Get the full content of a specific team document. ' +
-            'Use this when you need the team domain context (ubiquitous language, entities, business rules), ' +
-            'tech preferences (approved stack, patterns), or architecture constraints. ' +
-            'Types: team_charter, definition_of_done, tech_preferences, ' +
-            'architecture_constraints, slo_targets, domain_context.', {
-            teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
-            type: z
-                .string()
-                .describe('Document type -- get available types from taiga_list_team_documents. ' +
-                'Most useful: domain_context (entities, language), tech_preferences (stack, patterns)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.getTeamDocument(params.teamId, params.type);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-    // Team document write requires both teams:read (to find the team) and tenant:documents:write
-    if (client.hasCapability('teams:read') && client.hasCapability('tenant:documents:write')) {
-        server.tool('taiga_update_team_document', 'Update the draft content of a team document. ' +
-            'Only updates the draft -- does not publish. Use this when you notice team conventions, ' +
-            'domain context, or tech preferences need updating while working on the codebase.', {
-            teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
-            type: z.string().describe('Document type (e.g. domain_context, tech_preferences)'),
-            data: z.record(z.string(), z.unknown()).describe('Document content to save as JSON'),
-        }, { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async (params) => {
-            const { teamId, type, ...body } = params;
-            const result = await client.saveTeamDocumentDraft(teamId, type, body);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-}

package/dist/tools/index.d.ts

@@ -1,12 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { TaigaClient } from '../client.js';
-/**
- * Register all MCP tools based on the API key's effective capabilities.
- * Only tools matching the key's scopes are registered -- the AI assistant
- * never sees tools it can't use.
- *
- * Beta scope: Knowledge base access (policies, skills, team documents).
- * Post-beta: Projects, backlog items, environments, composite tools.
- */
-export declare function registerAllTools(server: McpServer, client: TaigaClient): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAMhD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAK7E"}

package/dist/tools/index.js

@@ -1,18 +0,0 @@
-import { registerProjectTools } from './projects.js';
-import { registerDocumentTools } from './documents.js';
-import { registerBacklogTools } from './backlogs.js';
-import { registerSkillTools } from './skills.js';
-/**
- * Register all MCP tools based on the API key's effective capabilities.
- * Only tools matching the key's scopes are registered -- the AI assistant
- * never sees tools it can't use.
- *
- * Beta scope: Knowledge base access (policies, skills, team documents).
- * Post-beta: Projects, backlog items, environments, composite tools.
- */
-export function registerAllTools(server, client) {
-    registerProjectTools(server, client);
-    registerDocumentTools(server, client);
-    registerBacklogTools(server, client);
-    registerSkillTools(server, client);
-}

package/dist/tools/projects.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { TaigaClient } from '../client.js';
-export declare function registerProjectTools(server: McpServer, client: TaigaClient): void;
-//# sourceMappingURL=projects.d.ts.map

package/dist/tools/projects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../src/tools/projects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,QA0F1E"}

package/dist/tools/projects.js

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import { summarizeList } from './summarize.js';
-export function registerProjectTools(server, client) {
-    if (client.hasCapability('teams:read')) {
-        server.tool('taiga_list_teams', 'List all teams in the organization. Use this to find team IDs ' +
-            'for reading team documents, skills, and understanding team structure. ' +
-            'Teams own domain context, tech preferences, and architecture constraints.', {
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listTeams(params);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-    if (client.hasCapability('projects:read')) {
-        server.tool('taiga_list_projects', 'List projects in the organization. Use this to find the project you are working on ' +
-            'so you can read its specification, architecture, and threat model. ' +
-            'Can filter by team or status.', {
-            teamId: z.string().uuid().optional().describe('Filter by team ID -- get team IDs from taiga_list_teams'),
-            status: z
-                .enum(['draft', 'active', 'archived'])
-                .optional()
-                .describe('Filter by status (draft = intake in progress, active = development)'),
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listProjects(params);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-        server.tool('taiga_list_project_documents', 'List documents for a specific project (names and types only). ' +
-            'Project documents are generated during intake: specification (requirements), ' +
-            'architecture (system design), technology decisions, data flow, privacy assessment, ' +
-            'threat model (security risks), risk register, and user flow. ' +
-            'Use taiga_get_project_document to read the full content.', {
-            projectId: z.string().uuid().describe('Project ID -- get from taiga_list_projects'),
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listProjectDocuments(params.projectId, { limit: params.limit });
-            const summaries = summarizeList(result.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }],
-            };
-        });
-        server.tool('taiga_get_project_document', 'Get the full content of a specific project 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.', {
-            projectId: z.string().uuid().describe('Project ID -- get from taiga_list_projects'),
-            type: z
-                .string()
-                .describe('Document type -- get available types from taiga_list_project_documents. ' +
-                'Common: specification, architecture, threat_model, technology_decisions'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.getProjectDocument(params.projectId, params.type);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-}

package/dist/tools/skills.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { TaigaClient } from '../client.js';
-export declare function registerSkillTools(server: McpServer, client: TaigaClient): void;
-//# sourceMappingURL=skills.d.ts.map

package/dist/tools/skills.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/tools/skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,QA8DxE"}

package/dist/tools/skills.js

@@ -1,45 +0,0 @@
-import { z } from 'zod';
-import { summarizeList } from './summarize.js';
-export function registerSkillTools(server, client) {
-    if (client.hasCapability('tenant:documents:read')) {
-        server.tool('taiga_list_skills', 'List agent skills available in the organization (names and descriptions only). ' +
-            'Skills are reusable knowledge modules that guide coding: coding standards, ' +
-            'security requirements, architecture patterns, database conventions, etc. ' +
-            'Use taiga_get_skill with the skill ID to read the full content.', {
-            limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.listSkills(params);
-            const summaries = summarizeList(result.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }],
-            };
-        });
-        server.tool('taiga_get_skill', 'Get the full content of a specific agent skill. ' +
-            'Use this when you need detailed coding guidelines, patterns, or conventions ' +
-            'for a specific topic (e.g., security requirements, API design, testing strategy). ' +
-            'Returns the complete markdown content with code examples and best practices.', {
-            id: z.string().uuid().describe('Skill ID -- get from taiga_list_skills'),
-        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
-            const result = await client.getSkill(params.id);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-    if (client.hasCapability('tenant:documents:write')) {
-        server.tool('taiga_update_skill', 'Update an agent skill (coding standards, patterns, conventions). ' +
-            'Use this when you notice a skill is outdated, incomplete, or needs corrections ' +
-            'while working on the codebase. Changes are saved immediately.', {
-            id: z.string().uuid().describe('Skill ID -- get from taiga_list_skills'),
-            name: z.string().optional().describe('Updated skill name'),
-            description: z.string().optional().describe('Updated skill description'),
-            content: z.string().optional().describe('Updated skill content (markdown)'),
-        }, { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async (params) => {
-            const { id, ...body } = params;
-            const result = await client.updateSkill(id, body);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
-            };
-        });
-    }
-}