@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/outbox.js

@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: MIT
+/**
+ * FEAT-111 Wave 2 — Outbox MCP tools:
+ *   tacit_outbox_write  — Write an envelope to the local outbox queue
+ *   tacit_outbox_flush  — Trigger an immediate drain of pending envelopes
+ *   tacit_outbox_status — Check outbox queue status (pending/delivered/failed counts)
+ */
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { execSync } from 'child_process';
+// ─── tacit_outbox_write ──────────────────────────────────────────────────────
+export const outboxWriteInputSchema = z.object({
+    title: z.string().min(1).describe('Title of the content'),
+    content: z.string().min(1).describe('Content body (markdown or plain text)'),
+    placement: z.object({
+        kb: z.object({
+            collections: z.array(z.union([
+                z.string().uuid(),
+                z.object({
+                    name: z.string().min(1),
+                    slug: z.string().optional(),
+                }),
+            ])),
+        }).optional(),
+        pyramid: z.object({
+            portfolio_id: z.string().uuid().optional(),
+            program_id: z.string().uuid().optional(),
+            dossiers: z.array(z.union([
+                z.string().uuid(),
+                z.object({ name: z.string().min(1) }),
+            ])).optional(),
+        }).optional(),
+    }).describe('Placement envelope — at least one of kb or pyramid required'),
+    content_origin: z.enum(['agent', 'human', 'git_sync']).default('agent'),
+    source_agent_id: z.string().optional().describe('Identifier for the source agent'),
+    autonomy_level: z.enum(['MENTAT', 'TWIN']).optional().describe('Agent autonomy level (SCRIBE excluded)'),
+    idempotency_key: z.string().optional().describe('Dedup key — same key = same content'),
+    replaces_object_id: z.string().uuid().optional().describe('UUID of object this replaces'),
+    content_format: z.enum(['MARKDOWN', 'HTML', 'PLAIN_TEXT']).default('MARKDOWN'),
+});
+export const OUTBOX_WRITE_TOOL_DEF = {
+    name: 'tacit_outbox_write',
+    description: 'Write content to the Tacit outbox queue (.tacit/outbox/pending/). ' +
+        'Content is drained to the API within 60s by the LaunchAgent, or immediately via tacit_outbox_flush. ' +
+        'Requires placement (at least one of kb or pyramid). SCRIBE autonomy level cannot write.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            title: { type: 'string', description: 'Content title' },
+            content: { type: 'string', description: 'Content body' },
+            placement: {
+                type: 'object',
+                description: 'Placement envelope (kb and/or pyramid)',
+                properties: {
+                    kb: {
+                        type: 'object',
+                        properties: {
+                            collections: {
+                                type: 'array',
+                                items: { oneOf: [{ type: 'string' }, { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }] },
+                            },
+                        },
+                    },
+                    pyramid: {
+                        type: 'object',
+                        properties: {
+                            portfolio_id: { type: 'string' },
+                            program_id: { type: 'string' },
+                            dossiers: { type: 'array', items: { oneOf: [{ type: 'string' }, { type: 'object' }] } },
+                        },
+                    },
+                },
+            },
+            content_origin: { type: 'string', enum: ['agent', 'human', 'git_sync'], default: 'agent' },
+            source_agent_id: { type: 'string', description: 'Source agent identifier' },
+            autonomy_level: { type: 'string', enum: ['MENTAT', 'TWIN'] },
+            idempotency_key: { type: 'string', description: 'Deduplication key' },
+            replaces_object_id: { type: 'string', description: 'UUID of object this replaces' },
+            content_format: { type: 'string', enum: ['MARKDOWN', 'HTML', 'PLAIN_TEXT'], default: 'MARKDOWN' },
+        },
+        required: ['title', 'content', 'placement'],
+    },
+};
+function getOutboxDir() {
+    return path.resolve('.tacit', 'outbox');
+}
+export async function handleOutboxWrite(args) {
+    const parsed = outboxWriteInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    const input = parsed.data;
+    if (!input.placement.kb && !input.placement.pyramid) {
+        return { content: [{ type: 'text', text: 'Placement must include at least one of kb or pyramid' }], isError: true };
+    }
+    const outboxDir = getOutboxDir();
+    const pendingDir = path.join(outboxDir, 'pending');
+    try {
+        fs.mkdirSync(pendingDir, { recursive: true });
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Failed to create outbox directory: ${err}` }], isError: true };
+    }
+    const idempotencyKey = input.idempotency_key || crypto.randomUUID();
+    const envelope = {
+        title: input.title,
+        content: input.content,
+        content_format: input.content_format,
+        placement: input.placement,
+        content_origin: input.content_origin,
+        source_agent_id: input.source_agent_id,
+        autonomy_level: input.autonomy_level,
+        idempotency_key: idempotencyKey,
+        replaces_object_id: input.replaces_object_id,
+        queued_at: new Date().toISOString(),
+    };
+    const filename = `${Date.now()}_${idempotencyKey.slice(0, 8)}.json`;
+    const filepath = path.join(pendingDir, filename);
+    // Security: validate filename has no path traversal
+    if (filename.includes('..') || filename.includes('/')) {
+        return { content: [{ type: 'text', text: 'Invalid envelope filename' }], isError: true };
+    }
+    try {
+        fs.writeFileSync(filepath, JSON.stringify(envelope, null, 2), 'utf-8');
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Failed to write envelope: ${err}` }], isError: true };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    status: 'queued',
+                    envelope_path: filepath,
+                    idempotency_key: idempotencyKey,
+                }),
+            }],
+    };
+}
+// ─── tacit_outbox_flush ──────────────────────────────────────────────────────
+export const OUTBOX_FLUSH_TOOL_DEF = {
+    name: 'tacit_outbox_flush',
+    description: 'Immediately drain all pending outbox envelopes to the Tacit API. ' +
+        'Equivalent to running scripts/outbox-drain.sh.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export async function handleOutboxFlush(_args) {
+    const drainScript = path.resolve('scripts', 'outbox-drain.sh');
+    if (!fs.existsSync(drainScript)) {
+        return { content: [{ type: 'text', text: 'Drain script not found at scripts/outbox-drain.sh' }], isError: true };
+    }
+    try {
+        const output = execSync(`bash "${drainScript}"`, {
+            timeout: 60_000,
+            encoding: 'utf-8',
+            env: { ...process.env },
+        });
+        return { content: [{ type: 'text', text: output || 'Drain complete (no pending envelopes)' }] };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: `Drain failed: ${msg}` }], isError: true };
+    }
+}
+// ─── tacit_outbox_status ─────────────────────────────────────────────────────
+export const OUTBOX_STATUS_TOOL_DEF = {
+    name: 'tacit_outbox_status',
+    description: 'Check the status of the outbox queue: counts of pending, delivered, and failed envelopes.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export async function handleOutboxStatus(_args) {
+    const outboxDir = getOutboxDir();
+    const countFiles = (dir) => {
+        try {
+            return fs.readdirSync(dir).filter((f) => f.endsWith('.json')).length;
+        }
+        catch {
+            return 0;
+        }
+    };
+    const status = {
+        pending: countFiles(path.join(outboxDir, 'pending')),
+        delivered: countFiles(path.join(outboxDir, 'delivered')),
+        failed: countFiles(path.join(outboxDir, 'failed')),
+    };
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(status),
+            }],
+    };
+}
+export function registerOutboxTools(server) {
+    server.tool('tacit_outbox_write', 'Write content to the Tacit outbox queue (.tacit/outbox/pending/).', {
+        title: z.string().min(1).describe('Title of the content'),
+        content: z.string().min(1).describe('Content body'),
+        placement: z.record(z.unknown()).describe('Placement envelope — at least one of kb or pyramid required'),
+        content_origin: z.enum(['agent', 'human', 'git_sync']).default('agent'),
+        source_agent_id: z.string().optional().describe('Source agent identifier'),
+        autonomy_level: z.enum(['MENTAT', 'TWIN']).optional().describe('Agent autonomy level'),
+        idempotency_key: z.string().optional().describe('Dedup key'),
+        replaces_object_id: z.string().optional().describe('UUID of object this replaces'),
+        content_format: z.enum(['MARKDOWN', 'HTML', 'PLAIN_TEXT']).default('MARKDOWN'),
+    }, async (args) => {
+        return handleOutboxWrite(args);
+    });
+    server.tool('tacit_outbox_flush', 'Immediately drain all pending outbox envelopes to the Tacit API.', {}, async () => {
+        return handleOutboxFlush({});
+    });
+    server.tool('tacit_outbox_status', 'Check outbox queue status (pending/delivered/failed counts).', {}, async () => {
+        return handleOutboxStatus({});
+    });
+}

package/dist/tools/people.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { TacitClient } from '../client.js';
+export declare function registerPeopleTools(server: McpServer, getClient: () => Promise<TacitClient>): void;

package/dist/tools/people.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { TacitApiError } from '../client.js';
+import { success, error } from './errors.js';
+export function registerPeopleTools(server, getClient) {
+    server.tool('tacit_list_people', 'List all people in the current workspace.', {}, async () => {
+        try {
+            const client = await getClient();
+            const data = await client.request('GET', '/api/v1/people');
+            return success(data);
+        }
+        catch (e) {
+            if (e instanceof TacitApiError)
+                return error(e.message);
+            return error(`Unexpected error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.tool('tacit_get_person', 'Get a person by ID.', {
+        person_id: z.string().uuid().describe('Person UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClient();
+            const data = await client.request('GET', `/api/v1/people/${args.person_id}`);
+            return success(data);
+        }
+        catch (e) {
+            if (e instanceof TacitApiError)
+                return error(e.message);
+            return error(`Unexpected error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.tool('tacit_create_person', 'Create a new person record.', {
+        name: z.string().describe("Person's name"),
+        url: z.string().url().optional().describe("Person's URL (LinkedIn, website, etc.)"),
+        email: z.string().email().optional().describe("Person's email address"),
+    }, async (args) => {
+        try {
+            const client = await getClient();
+            const data = await client.request('POST', '/api/v1/people', args);
+            return success(data);
+        }
+        catch (e) {
+            if (e instanceof TacitApiError)
+                return error(e.message);
+            return error(`Unexpected error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.tool('tacit_get_myself', "Get the authenticated user's own person record.", {}, async () => {
+        try {
+            const client = await getClient();
+            const data = await client.request('GET', '/api/v1/people/myself');
+            return success(data);
+        }
+        catch (e) {
+            if (e instanceof TacitApiError)
+                return error(e.message);
+            return error(`Unexpected error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+}