@tacitai/mcp-server 0.1.0

package/dist/tools/synthesize.d.ts

@@ -0,0 +1,68 @@
+/**
+ * tacit_synthesize — canonical synthesis tool
+ *
+ * JSON path (stream:false): POST /api/v1/mind/synthesize
+ * SSE  path (stream:true):  POST /api/v1/mind/synthesize/stream
+ *
+ * Aliases: tacit_ask / tacit_compose route to this same handler.
+ * stream:true selects the SSE variant and returns aggregated chunks.
+ */
+import { z } from 'zod';
+import { TacitClient } from '../client.js';
+export declare const synthesizeInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    stream?: boolean | undefined;
+    scope?: string | undefined;
+}, {
+    query: string;
+    stream?: boolean | undefined;
+    scope?: string | undefined;
+}>;
+export type SynthesizeInput = z.infer<typeof synthesizeInputSchema>;
+export declare const SYNTHESIZE_TOOL_DEF: {
+    name: "tacit_synthesize";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            scope: {
+                type: string;
+                description: string;
+            };
+            stream: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+/**
+ * Build a synthesize request object. Call .execute() to perform the HTTP call.
+ * Exported for testability (allows injecting a mock TacitClient).
+ */
+export declare function buildSynthesizeRequest(client: TacitClient, input: SynthesizeInput): ToolRequest;
+export declare function handleSynthesize(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/synthesize.js

@@ -0,0 +1,93 @@
+"use strict";
+// SPDX-License-Identifier: MIT
+/**
+ * tacit_synthesize — canonical synthesis tool
+ *
+ * JSON path (stream:false): POST /api/v1/mind/synthesize
+ * SSE  path (stream:true):  POST /api/v1/mind/synthesize/stream
+ *
+ * Aliases: tacit_ask / tacit_compose route to this same handler.
+ * stream:true selects the SSE variant and returns aggregated chunks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTHESIZE_TOOL_DEF = exports.synthesizeInputSchema = void 0;
+exports.buildSynthesizeRequest = buildSynthesizeRequest;
+exports.handleSynthesize = handleSynthesize;
+const zod_1 = require("zod");
+const client_js_1 = require("../client.js");
+exports.synthesizeInputSchema = zod_1.z.object({
+    query: zod_1.z.string().min(1).describe('Question or synthesis prompt'),
+    scope: zod_1.z.string().optional().describe('Optional scope filter (e.g. portfolio or program id)'),
+    stream: zod_1.z.boolean().optional().describe('If true, use SSE stream variant (/mind/synthesize/stream)'),
+});
+exports.SYNTHESIZE_TOOL_DEF = {
+    name: 'tacit_synthesize',
+    description: 'Synthesize knowledge from the Tacit workspace. ' +
+        'stream:false (default) → POST /api/v1/mind/synthesize (JSON). ' +
+        'stream:true → POST /api/v1/mind/synthesize/stream (SSE; also exposed as tacit_ask / tacit_compose aliases).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Question or synthesis prompt' },
+            scope: { type: 'string', description: 'Optional scope filter' },
+            stream: { type: 'boolean', description: 'Use SSE stream variant if true' },
+        },
+        required: ['query'],
+    },
+};
+/**
+ * Build a synthesize request object. Call .execute() to perform the HTTP call.
+ * Exported for testability (allows injecting a mock TacitClient).
+ */
+function buildSynthesizeRequest(client, input) {
+    return {
+        async execute() {
+            const { query, scope, stream } = input;
+            const body = { query };
+            if (scope)
+                body['scope'] = scope;
+            try {
+                if (stream) {
+                    // SSE path: POST /api/v1/mind/synthesize/stream
+                    const chunks = [];
+                    for await (const chunk of client.postSSE('/api/v1/mind/synthesize/stream', body)) {
+                        chunks.push(chunk);
+                    }
+                    if (chunks.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ chunks: 0, text: '' }) }],
+                        };
+                    }
+                    // Aggregate: return all chunks as content items for D7 chunk counting.
+                    return {
+                        content: chunks.map((c) => ({ type: 'text', text: c })),
+                    };
+                }
+                else {
+                    // JSON path: POST /api/v1/mind/synthesize
+                    const result = await client.post('/api/v1/mind/synthesize', body);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result) }],
+                    };
+                }
+            }
+            catch (err) {
+                if (err instanceof client_js_1.TacitApiError) {
+                    return { content: [{ type: 'text', text: `API error ${err.statusCode}: ${err.body}` }], isError: true };
+                }
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+            }
+        },
+    };
+}
+async function handleSynthesize(args) {
+    const parsed = exports.synthesizeInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }],
+            isError: true,
+        };
+    }
+    return buildSynthesizeRequest((0, client_js_1.getClient)(), parsed.data).execute();
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@tacitai/mcp-server",
+  "version": "0.1.0",
+  "description": "stdio MCP server wrapping Tacit /api/v1 REST/SSE API",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scottkmcmillan/tacit.git",
+    "directory": "packages/tacit-mcp-server"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "tacit-mcp-server": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "compatibility": {
+    "coreArtifact": ">=1.0.0 <2.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "semver": "^7.6.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/semver": "^7.5.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.7"
+  }
+}