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

package/dist/client.js

@@ -1,228 +0,0 @@
-/**
- * HTTP client for the Taiga API.
- * Used by the MCP server to proxy tool calls to the backend.
- */
-export class TaigaClient {
-    baseUrl;
-    apiKey;
-    introspection = null;
-    constructor(opts) {
-        this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
-        this.apiKey = opts.apiKey;
-    }
-    async request(method, path, body) {
-        const url = `${this.baseUrl}/v1${path}`;
-        const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'taiga-ai-mcp-server/0.0.1',
-        };
-        const response = await fetch(url, {
-            method,
-            headers,
-            body: body ? JSON.stringify(body) : undefined,
-        });
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            throw new Error(`Taiga API ${method} ${path} failed (${response.status}): ${text}`);
-        }
-        return response.json();
-    }
-    // ---------------------------------------------------------------------------
-    // Auth
-    // ---------------------------------------------------------------------------
-    async introspect() {
-        const result = await this.request('GET', '/auth/introspect');
-        this.introspection = result.data;
-        return result.data;
-    }
-    getIntrospection() {
-        return this.introspection;
-    }
-    hasCapability(capability) {
-        if (!this.introspection)
-            return false;
-        return this.introspection.capabilities.includes(capability);
-    }
-    // ---------------------------------------------------------------------------
-    // Projects
-    // ---------------------------------------------------------------------------
-    async listProjects(opts) {
-        const params = new URLSearchParams();
-        if (opts?.teamId)
-            params.set('teamId', opts.teamId);
-        if (opts?.status)
-            params.set('status', opts.status);
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/projects${qs ? `?${qs}` : ''}`);
-    }
-    async getProject(id) {
-        return this.request('GET', `/projects/${id}`);
-    }
-    // ---------------------------------------------------------------------------
-    // Documents (tenant-level policies)
-    // ---------------------------------------------------------------------------
-    async listTenantDocuments(opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/tenants/current/documents${qs ? `?${qs}` : ''}`);
-    }
-    async getTenantDocument(type) {
-        return this.request('GET', `/tenants/current/documents/${type}`);
-    }
-    async saveTenantDocumentDraft(type, body) {
-        return this.request('PUT', `/tenants/current/documents/${type}/draft`, body);
-    }
-    // ---------------------------------------------------------------------------
-    // Team Documents
-    // ---------------------------------------------------------------------------
-    async listTeamDocuments(teamId, opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/teams/${teamId}/documents${qs ? `?${qs}` : ''}`);
-    }
-    async getTeamDocument(teamId, type) {
-        return this.request('GET', `/teams/${teamId}/documents/${type}`);
-    }
-    async saveTeamDocumentDraft(teamId, type, body) {
-        return this.request('PUT', `/teams/${teamId}/documents/${type}/draft`, body);
-    }
-    // ---------------------------------------------------------------------------
-    // Project Documents
-    // ---------------------------------------------------------------------------
-    async listProjectDocuments(projectId, opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/projects/${projectId}/documents${qs ? `?${qs}` : ''}`);
-    }
-    async getProjectDocument(projectId, type) {
-        return this.request('GET', `/projects/${projectId}/documents/${type}`);
-    }
-    // ---------------------------------------------------------------------------
-    // Skills (agent skills)
-    // ---------------------------------------------------------------------------
-    async listSkills(opts) {
-        const params = new URLSearchParams();
-        if (opts?.scope)
-            params.set('scope', opts.scope);
-        if (opts?.scopeId)
-            params.set('scopeId', opts.scopeId);
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/agent-skills${qs ? `?${qs}` : ''}`);
-    }
-    async getSkill(id) {
-        return this.request('GET', `/agent-skills/${id}`);
-    }
-    async updateSkill(id, body) {
-        return this.request('PATCH', `/agent-skills/${id}`, body);
-    }
-    // ---------------------------------------------------------------------------
-    // Team Documents
-    // ---------------------------------------------------------------------------
-    /**
-     * Fetch the full context for a project in parallel: project metadata,
-     * team documents, project documents, and team skills.
-     * Returns a structured bundle optimized for coding agent consumption.
-     */
-    async getProjectContext(projectId) {
-        // First fetch the project to get the teamId
-        const project = await this.request('GET', `/projects/${projectId}`);
-        const teamId = project.data.teamId;
-        // Fetch everything in parallel
-        const [projectDocs, teamDocs, skills] = await Promise.all([
-            this.listProjectDocuments(projectId, { limit: 20 }).catch(() => ({ data: [] })),
-            teamId
-                ? this.listTeamDocuments(teamId, { limit: 20 }).catch(() => ({ data: [] }))
-                : Promise.resolve({ data: [] }),
-            this.listSkills({ limit: 100 }).catch(() => ({ data: [] })),
-        ]);
-        // Fetch full content for key documents (in parallel)
-        const keyProjectDocTypes = ['specification', 'architecture', 'technology_decisions'];
-        const keyTeamDocTypes = ['domain_context', 'tech_preferences', 'architecture_constraints'];
-        const docFetches = [];
-        for (const docType of keyProjectDocTypes) {
-            const exists = projectDocs.data.some((d) => d.type === docType && !d.isDraft);
-            if (exists) {
-                docFetches.push(this.getProjectDocument(projectId, docType)
-                    .then((r) => ({ type: docType, scope: 'project', data: r.data }))
-                    .catch(() => ({ type: docType, scope: 'project', data: null })));
-            }
-        }
-        if (teamId) {
-            for (const docType of keyTeamDocTypes) {
-                const exists = teamDocs.data.some((d) => d.type === docType && !d.isDraft);
-                if (exists) {
-                    docFetches.push(this.getTeamDocument(teamId, docType)
-                        .then((r) => ({ type: docType, scope: 'team', data: r.data }))
-                        .catch(() => ({ type: docType, scope: 'team', data: null })));
-                }
-            }
-        }
-        const fetchedDocs = await Promise.all(docFetches);
-        // Assemble context bundle
-        const context = {
-            project: project.data,
-            documents: {
-                project: Object.fromEntries(fetchedDocs.filter((d) => d.scope === 'project' && d.data).map((d) => [d.type, d.data])),
-                team: Object.fromEntries(fetchedDocs.filter((d) => d.scope === 'team' && d.data).map((d) => [d.type, d.data])),
-            },
-            available_documents: {
-                project: projectDocs.data.map((d) => ({
-                    type: d.type,
-                    name: d.name,
-                    version: d.version,
-                    isDraft: d.isDraft,
-                })),
-                team: teamDocs.data.map((d) => ({
-                    type: d.type,
-                    name: d.name,
-                    version: d.version,
-                    isDraft: d.isDraft,
-                })),
-            },
-            skills_summary: skills.data
-                .filter((s) => !s.teamId || s.teamId === teamId)
-                .map((s) => ({ id: s.id, name: s.name, slug: s.slug, description: s.description })),
-        };
-        return context;
-    }
-    // ---------------------------------------------------------------------------
-    // Backlog
-    // ---------------------------------------------------------------------------
-    async listBacklogItems(projectId, opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/projects/${projectId}/backlog${qs ? `?${qs}` : ''}`);
-    }
-    async getBacklogItem(itemId) {
-        return this.request('GET', `/backlog/${itemId}`);
-    }
-    // ---------------------------------------------------------------------------
-    // Environments
-    // ---------------------------------------------------------------------------
-    async listEnvironments(projectId) {
-        return this.request('GET', `/projects/${projectId}/environments`);
-    }
-    // ---------------------------------------------------------------------------
-    // Teams
-    // ---------------------------------------------------------------------------
-    async listTeams(opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const qs = params.toString();
-        return this.request('GET', `/teams${qs ? `?${qs}` : ''}`);
-    }
-}

package/dist/client.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=client.test.d.ts.map

package/dist/client.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../src/client.test.ts"],"names":[],"mappings":""}

package/dist/client.test.js

@@ -1,203 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { TaigaClient } from './client.js';
-// ---------------------------------------------------------------------------
-// Helpers -- thin wrappers to reduce boilerplate, not to obscure intent
-// ---------------------------------------------------------------------------
-function stubFetch(status, body) {
-    const spy = vi.fn().mockResolvedValue({
-        ok: status >= 200 && status < 300,
-        status,
-        json: () => Promise.resolve(body),
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-    vi.stubGlobal('fetch', spy);
-    return spy;
-}
-function makeClient(opts) {
-    return new TaigaClient({
-        baseUrl: opts?.baseUrl ?? 'https://api.test.com',
-        apiKey: opts?.apiKey ?? 'taiga_sk_live_testkey123',
-    });
-}
-async function clientWithCapabilities(caps) {
-    stubFetch(200, { data: { capabilities: caps } });
-    const client = makeClient();
-    await client.introspect();
-    return client;
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe('TaigaClient', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    // -------------------------------------------------------------------------
-    // Authentication -- the client must always identify itself correctly
-    // -------------------------------------------------------------------------
-    describe('authentication', () => {
-        it('should authenticate every request with the provided API key', async () => {
-            // Arrange
-            const spy = stubFetch(200, { data: [] });
-            const client = makeClient({ apiKey: 'taiga_sk_live_secret42' });
-            // Act
-            await client.listProjects();
-            // Assert
-            const headers = spy.mock.calls[0][1].headers;
-            expect(headers.Authorization).toBe('Bearer taiga_sk_live_secret42');
-        });
-        it('should identify itself as taiga-ai-mcp-server in every request', async () => {
-            const spy = stubFetch(200, { data: [] });
-            await makeClient().listProjects();
-            expect(spy.mock.calls[0][1].headers['User-Agent']).toMatch(/^taiga-ai-mcp-server\//);
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Error handling -- failures must surface clearly, never silently swallow
-    // -------------------------------------------------------------------------
-    describe('error handling', () => {
-        it('should reject with status code and body when API returns an error', async () => {
-            stubFetch(403, { error: 'Forbidden' });
-            const client = makeClient();
-            await expect(client.listProjects()).rejects.toThrow(/403.*Forbidden/);
-        });
-        it('should reject with status code even when response body is unreadable', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-                ok: false,
-                status: 500,
-                text: () => Promise.reject(new Error('stream error')),
-            }));
-            await expect(makeClient().listProjects()).rejects.toThrow(/500/);
-        });
-        it('should reject when fetch itself throws (network failure)', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
-            await expect(makeClient().listProjects()).rejects.toThrow(/ECONNREFUSED/);
-        });
-    });
-    // -------------------------------------------------------------------------
-    // URL construction -- trailing slashes, optional params, nested paths
-    // -------------------------------------------------------------------------
-    describe('URL construction', () => {
-        it('should normalize trailing slashes in base URL', async () => {
-            const spy = stubFetch(200, { data: [] });
-            const client = makeClient({ baseUrl: 'https://api.test.com///' });
-            await client.listProjects();
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects');
-        });
-        it('should omit query string when no optional params are provided', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listProjects();
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects');
-        });
-        it('should include all optional filters as query params', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listProjects({ teamId: 't1', status: 'active', limit: 10 });
-            const url = spy.mock.calls[0][0];
-            expect(url).toContain('teamId=t1');
-            expect(url).toContain('status=active');
-            expect(url).toContain('limit=10');
-        });
-        it('should nest backlog items under the project path', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listBacklogItems('proj-1', { limit: 20 });
-            const url = spy.mock.calls[0][0];
-            expect(url).toContain('/v1/projects/proj-1/backlog');
-            expect(url).toContain('limit=20');
-        });
-        it('should nest environments under the project path', async () => {
-            const spy = stubFetch(200, { data: [] });
-            await makeClient().listEnvironments('proj-1');
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects/proj-1/environments');
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Introspection -- the foundation for capability-gated tool registration
-    // -------------------------------------------------------------------------
-    describe('introspection', () => {
-        it('should return and store the introspection result', async () => {
-            const expected = {
-                userId: 'u1',
-                tenantId: 't1',
-                email: 'test@example.com',
-                role: 'member',
-                capabilities: ['projects:read', 'teams:read'],
-            };
-            stubFetch(200, { data: expected });
-            const client = makeClient();
-            // Act
-            const result = await client.introspect();
-            // Assert -- both return value and stored state
-            expect(result).toEqual(expected);
-            expect(client.getIntrospection()).toEqual(expected);
-        });
-        it('should report no capabilities before introspect is called', () => {
-            const client = makeClient();
-            expect(client.hasCapability('projects:read')).toBe(false);
-        });
-        it('should correctly report granted vs missing capabilities', async () => {
-            const client = await clientWithCapabilities(['projects:read', 'teams:read']);
-            expect(client.hasCapability('projects:read')).toBe(true);
-            expect(client.hasCapability('teams:read')).toBe(true);
-            expect(client.hasCapability('backlog:read')).toBe(false);
-            expect(client.hasCapability('tenant:documents:write')).toBe(false);
-        });
-        it('should report no capabilities when key has empty scope', async () => {
-            const client = await clientWithCapabilities([]);
-            expect(client.hasCapability('projects:read')).toBe(false);
-        });
-    });
-    // -------------------------------------------------------------------------
-    // API methods -- each method hits the right endpoint with the right verb
-    // These are the HTTP contracts the Taiga API expects.
-    // -------------------------------------------------------------------------
-    describe('API contracts', () => {
-        it('should GET a single project by id', async () => {
-            const spy = stubFetch(200, { data: { id: 'p1', name: 'Alpha' } });
-            const result = await makeClient().getProject('p1');
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects/p1');
-            expect(result.data).toEqual({ id: 'p1', name: 'Alpha' });
-        });
-        it('should GET a single document by type from tenant path', async () => {
-            const spy = stubFetch(200, { data: { id: 'd1' } });
-            await makeClient().getTenantDocument('security_policy');
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/tenants/current/documents/security_policy');
-        });
-        it('should PUT a document draft with the provided body', async () => {
-            const spy = stubFetch(200, { data: { id: 'd1' } });
-            await makeClient().saveTenantDocumentDraft('security_policy', { data: { title: 'New' } });
-            expect(spy.mock.calls[0][1].method).toBe('PUT');
-            expect(spy.mock.calls[0][0]).toContain('/tenants/current/documents/security_policy/draft');
-            expect(JSON.parse(spy.mock.calls[0][1].body)).toEqual({
-                data: { title: 'New' },
-            });
-        });
-        it('should GET a single skill by id from agent-skills path', async () => {
-            const spy = stubFetch(200, { data: { id: 's1' } });
-            await makeClient().getSkill('s1');
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/agent-skills/s1');
-        });
-        it('should include scope filters when listing skills', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listSkills({ scope: 'team', scopeId: 't1', limit: 10 });
-            const url = spy.mock.calls[0][0];
-            expect(url).toContain('/v1/agent-skills');
-            expect(url).toContain('scope=team');
-            expect(url).toContain('scopeId=t1');
-        });
-        it('should GET a single backlog item by id (flat path)', async () => {
-            const spy = stubFetch(200, { data: { id: 'item-1' } });
-            await makeClient().getBacklogItem('item-1');
-            expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/backlog/item-1');
-        });
-        it('should GET teams with optional limit', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listTeams({ limit: 50 });
-            expect(spy.mock.calls[0][0]).toContain('/v1/teams?limit=50');
-        });
-        it('should GET documents from tenant path with optional limit', async () => {
-            const spy = stubFetch(200, { data: [], nextCursor: null });
-            await makeClient().listTenantDocuments({ limit: 5 });
-            expect(spy.mock.calls[0][0]).toContain('/v1/tenants/current/documents?limit=5');
-        });
-    });
-});

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/server.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=server.integration.test.d.ts.map

package/dist/server.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.integration.test.d.ts","sourceRoot":"","sources":["../src/server.integration.test.ts"],"names":[],"mappings":""}