@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/export.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Export tool:
+ *   tacit_export_to_git — POST /api/v1/export/git
+ */
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare const exportToGitInputSchema: z.ZodObject<{
+    artifact_id: z.ZodString;
+    output_path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    artifact_id: string;
+    output_path: string;
+}, {
+    artifact_id: string;
+    output_path: string;
+}>;
+export type ExportToGitInput = z.infer<typeof exportToGitInputSchema>;
+export declare const EXPORT_TO_GIT_TOOL_DEF: {
+    name: "tacit_export_to_git";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            artifact_id: {
+                type: string;
+                description: string;
+            };
+            output_path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildExportToGitRequest(client: TacitClient, input: ExportToGitInput): ToolRequest;
+export declare function handleExportToGit(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function registerExportTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/export.js

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Export tool:
+ *   tacit_export_to_git — POST /api/v1/export/git
+ */
+import { z } from 'zod';
+import { getClient } from '../client.js';
+import { apiErrorResult } from './errors.js';
+export const exportToGitInputSchema = z.object({
+    artifact_id: z.string().min(1).describe('Artifact UUID to export'),
+    output_path: z.string().min(1).describe('Local file path to export the artifact content to'),
+});
+export const EXPORT_TO_GIT_TOOL_DEF = {
+    name: 'tacit_export_to_git',
+    description: "Export an artifact's content to a local file path. Route: POST /api/v1/export/git.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            artifact_id: { type: 'string', description: 'Artifact UUID' },
+            output_path: { type: 'string', description: 'Local file path to export to' },
+        },
+        required: ['artifact_id', 'output_path'],
+    },
+};
+export function buildExportToGitRequest(client, input) {
+    return {
+        async execute() {
+            const { artifact_id, output_path } = input;
+            try {
+                const body = { artifact_id, output_path };
+                const result = await client.post('/api/v1/export/git', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/export/git');
+            }
+        },
+    };
+}
+export async function handleExportToGit(args) {
+    const parsed = exportToGitInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildExportToGitRequest(getClient(), parsed.data).execute();
+}
+export function registerExportTools(server, getClientFn) {
+    server.tool('tacit_export_to_git', "Export an artifact's content to a local file path. Route: POST /api/v1/export/git.", {
+        artifact_id: z.string().min(1).describe('Artifact UUID to export'),
+        output_path: z.string().min(1).describe('Local file path to export to'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildExportToGitRequest(client, args).execute();
+    });
+}

package/dist/tools/gm.d.ts

@@ -0,0 +1,214 @@
+/**
+ * GM (Gateway Manager) tools — unified content ingestion with classification
+ * and human-approved placement across lake, KB, and pyramid surfaces.
+ *
+ * Routes (Axum, all under /api/v1/gm):
+ *   POST /ingest   — ingest content, classify, propose placement
+ *   POST /approve  — approve placement targets for a catalog entry
+ */
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare const gmIngestInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    title: z.ZodString;
+    source_uri: z.ZodOptional<z.ZodString>;
+    content_type: z.ZodOptional<z.ZodString>;
+    classification_hints: z.ZodOptional<z.ZodObject<{
+        domain: z.ZodOptional<z.ZodString>;
+        content_type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        domain?: string | undefined;
+        content_type?: string | undefined;
+    }, {
+        domain?: string | undefined;
+        content_type?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    title: string;
+    source_uri?: string | undefined;
+    content_type?: string | undefined;
+    classification_hints?: {
+        domain?: string | undefined;
+        content_type?: string | undefined;
+    } | undefined;
+}, {
+    content: string;
+    title: string;
+    source_uri?: string | undefined;
+    content_type?: string | undefined;
+    classification_hints?: {
+        domain?: string | undefined;
+        content_type?: string | undefined;
+    } | undefined;
+}>;
+export type GmIngestInput = z.infer<typeof gmIngestInputSchema>;
+export declare const GM_INGEST_TOOL_DEF: {
+    name: "tacit_gm_ingest";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            source_uri: {
+                type: string;
+                description: string;
+            };
+            content_type: {
+                type: string;
+                description: string;
+            };
+            classification_hints: {
+                type: string;
+                properties: {
+                    domain: {
+                        type: string;
+                    };
+                    content_type: {
+                        type: string;
+                    };
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildGmIngestRequest(client: TacitClient, input: GmIngestInput): ToolRequest;
+export declare function handleGmIngest(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const gmApproveInputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+    approved_targets: z.ZodArray<z.ZodObject<{
+        surface: z.ZodEnum<["kb", "pyramid"]>;
+        collection_or_program: z.ZodOptional<z.ZodString>;
+        dossier_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        surface: "kb" | "pyramid";
+        dossier_id?: string | undefined;
+        collection_or_program?: string | undefined;
+    }, {
+        surface: "kb" | "pyramid";
+        dossier_id?: string | undefined;
+        collection_or_program?: string | undefined;
+    }>, "many">;
+    rejected_targets: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        surface: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        surface: string;
+        reason?: string | undefined;
+    }, {
+        surface: string;
+        reason?: string | undefined;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    catalog_id: string;
+    approved_targets: {
+        surface: "kb" | "pyramid";
+        dossier_id?: string | undefined;
+        collection_or_program?: string | undefined;
+    }[];
+    rejected_targets: {
+        surface: string;
+        reason?: string | undefined;
+    }[];
+}, {
+    catalog_id: string;
+    approved_targets: {
+        surface: "kb" | "pyramid";
+        dossier_id?: string | undefined;
+        collection_or_program?: string | undefined;
+    }[];
+    rejected_targets?: {
+        surface: string;
+        reason?: string | undefined;
+    }[] | undefined;
+}>;
+export type GmApproveInput = z.infer<typeof gmApproveInputSchema>;
+export declare const GM_APPROVE_TOOL_DEF: {
+    name: "tacit_gm_approve";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            catalog_id: {
+                type: string;
+                description: string;
+            };
+            approved_targets: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        surface: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        collection_or_program: {
+                            type: string;
+                            description: string;
+                        };
+                        dossier_id: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+                description: string;
+            };
+            rejected_targets: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        surface: {
+                            type: string;
+                            description: string;
+                        };
+                        reason: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildGmApproveRequest(client: TacitClient, input: GmApproveInput): ToolRequest;
+export declare function handleGmApprove(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function registerGmTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/gm.js

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: MIT
+/**
+ * GM (Gateway Manager) tools — unified content ingestion with classification
+ * and human-approved placement across lake, KB, and pyramid surfaces.
+ *
+ * Routes (Axum, all under /api/v1/gm):
+ *   POST /ingest   — ingest content, classify, propose placement
+ *   POST /approve  — approve placement targets for a catalog entry
+ */
+import { z } from 'zod';
+import { TacitClient, TacitApiError, TokenExpiredError } from '../client.js';
+function apiErrorResult(err, toolName) {
+    if (err instanceof TokenExpiredError) {
+        return {
+            content: [{ type: 'text', text: err.message }],
+            isError: true,
+        };
+    }
+    if (err instanceof TacitApiError) {
+        return { content: [{ type: 'text', text: `API error ${err.statusCode} on ${toolName}: ${err.body}` }], isError: true };
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}
+// ─── tacit_gm_ingest ────────────────────────────────────────────────────────
+export const gmIngestInputSchema = z.object({
+    content: z.string().min(1).describe('The content to ingest'),
+    title: z.string().min(1).describe('Title for the catalog entry'),
+    source_uri: z.string().optional().describe('Source URI (defaults to tacit://adhoc/<uuid>)'),
+    content_type: z.string().optional().describe('Content type (auto-detected if omitted)'),
+    classification_hints: z.object({
+        domain: z.string().optional(),
+        content_type: z.string().optional(),
+    }).optional().describe('Optional hints for the classifier'),
+});
+export const GM_INGEST_TOOL_DEF = {
+    name: 'tacit_gm_ingest',
+    description: 'Ingest content through the unified gateway manager. Classifies the content, creates a catalog entry and artifact, ' +
+        'and returns a placement proposal with suggested targets (KB, pyramid, or lake-only). ' +
+        'Route: POST /api/v1/gm/ingest.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            content: { type: 'string', description: 'The content to ingest' },
+            title: { type: 'string', description: 'Title for the catalog entry' },
+            source_uri: { type: 'string', description: 'Source URI (defaults to tacit://adhoc/<uuid>)' },
+            content_type: { type: 'string', description: 'Content type (auto-detected if omitted)' },
+            classification_hints: {
+                type: 'object',
+                properties: {
+                    domain: { type: 'string' },
+                    content_type: { type: 'string' },
+                },
+                description: 'Optional hints for the classifier',
+            },
+        },
+        required: ['content', 'title'],
+    },
+};
+export function buildGmIngestRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {
+                    content: input.content,
+                    title: input.title,
+                };
+                if (input.source_uri !== undefined)
+                    body['source_uri'] = input.source_uri;
+                if (input.content_type !== undefined)
+                    body['content_type'] = input.content_type;
+                if (input.classification_hints !== undefined)
+                    body['classification_hints'] = input.classification_hints;
+                const result = await client.post('/api/v1/gm/ingest', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_gm_ingest');
+            }
+        },
+    };
+}
+export async function handleGmIngest(args) {
+    const parsed = gmIngestInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildGmIngestRequest(new TacitClient(), parsed.data).execute();
+}
+// ─── tacit_gm_approve ───────────────────────────────────────────────────────
+export const gmApproveInputSchema = z.object({
+    catalog_id: z.string().uuid().describe('The catalog entry to approve placement for'),
+    approved_targets: z.array(z.object({
+        surface: z.enum(['kb', 'pyramid']),
+        collection_or_program: z.string().optional(),
+        dossier_id: z.string().uuid().optional(),
+    })).describe('Targets to approve for placement'),
+    rejected_targets: z.array(z.object({
+        surface: z.string(),
+        reason: z.string().optional(),
+    })).optional().default([]).describe('Targets to explicitly reject'),
+});
+export const GM_APPROVE_TOOL_DEF = {
+    name: 'tacit_gm_approve',
+    description: 'Approve placement targets for a catalog entry created by tacit_gm_ingest. ' +
+        'Routes the content to approved surfaces (KB article, pyramid artifact) and records rejections. ' +
+        'Route: POST /api/v1/gm/approve.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_id: { type: 'string', description: 'The catalog entry to approve placement for' },
+            approved_targets: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        surface: { type: 'string', enum: ['kb', 'pyramid'], description: 'Target surface' },
+                        collection_or_program: { type: 'string', description: 'KB collection or pyramid program name' },
+                        dossier_id: { type: 'string', description: 'Dossier UUID for pyramid placement' },
+                    },
+                    required: ['surface'],
+                },
+                description: 'Targets to approve for placement',
+            },
+            rejected_targets: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        surface: { type: 'string', description: 'Surface being rejected' },
+                        reason: { type: 'string', description: 'Reason for rejection' },
+                    },
+                    required: ['surface'],
+                },
+                description: 'Targets to explicitly reject',
+            },
+        },
+        required: ['catalog_id', 'approved_targets'],
+    },
+};
+export function buildGmApproveRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {
+                    catalog_id: input.catalog_id,
+                    approved_targets: input.approved_targets,
+                };
+                if (input.rejected_targets !== undefined && input.rejected_targets.length > 0) {
+                    body['rejected_targets'] = input.rejected_targets;
+                }
+                const result = await client.post('/api/v1/gm/approve', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_gm_approve');
+            }
+        },
+    };
+}
+export async function handleGmApprove(args) {
+    const parsed = gmApproveInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildGmApproveRequest(new TacitClient(), parsed.data).execute();
+}
+// ─── Registration ───────────────────────────────────────────────────────────
+export function registerGmTools(server, getClientFn) {
+    server.tool('tacit_gm_ingest', GM_INGEST_TOOL_DEF.description, {
+        content: z.string().min(1).describe('The content to ingest'),
+        title: z.string().min(1).describe('Title for the catalog entry'),
+        source_uri: z.string().optional().describe('Source URI (defaults to tacit://adhoc/<uuid>)'),
+        content_type: z.string().optional().describe('Content type (auto-detected if omitted)'),
+        classification_hints: z.object({
+            domain: z.string().optional(),
+            content_type: z.string().optional(),
+        }).optional().describe('Optional hints for the classifier'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildGmIngestRequest(client, args).execute();
+    });
+    server.tool('tacit_gm_approve', GM_APPROVE_TOOL_DEF.description, {
+        catalog_id: z.string().uuid().describe('The catalog entry to approve placement for'),
+        approved_targets: z.array(z.object({
+            surface: z.enum(['kb', 'pyramid']),
+            collection_or_program: z.string().optional(),
+            dossier_id: z.string().uuid().optional(),
+        })).describe('Targets to approve for placement'),
+        rejected_targets: z.array(z.object({
+            surface: z.string(),
+            reason: z.string().optional(),
+        })).optional().default([]).describe('Targets to explicitly reject'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildGmApproveRequest(client, args).execute();
+    });
+}

package/dist/tools/ingest.d.ts

@@ -1,7 +1,8 @@
 /**
  * Ingest tools:
- *   tacit_ingest_file — POST /api/v1/portfolios/:id/ingest
- *   tacit_ingest_url  — POST /api/v1/portfolios/:id/ingest-url
+ *   tacit_ingest_file        — POST /api/v1/portfolios/:id/ingest
+ *   tacit_ingest_url         — POST /api/v1/portfolios/:id/ingest-url
+ *   tacit_ingest_url_general — POST /api/v1/portfolios/:id/ingest-url-general (FEAT-175)
  *
  * Both require portfolio_id input.
  *
@@ -15,6 +16,7 @@
  * (no DNS resolution required for the guard to function).
  */
 import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { TacitClient } from '../client.js';
 export interface ToolRequest {
     execute(): Promise<{
@@ -93,17 +95,68 @@ export declare function handleIngestFile(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare const ingestUrlGeneralInputSchema: z.ZodObject<{
+    portfolio_id: z.ZodString;
+    url: z.ZodString;
+    program_id: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    portfolio_id: string;
+    title?: string | undefined;
+    program_id?: string | undefined;
+}, {
+    url: string;
+    portfolio_id: string;
+    title?: string | undefined;
+    program_id?: string | undefined;
+}>;
+export type IngestUrlGeneralInput = z.infer<typeof ingestUrlGeneralInputSchema>;
+export declare const INGEST_URL_GENERAL_TOOL_DEF: {
+    name: "tacit_ingest_url_general";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            portfolio_id: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            program_id: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildIngestUrlGeneralRequest(client: TacitClient, input: IngestUrlGeneralInput): ToolRequest;
+export declare function handleIngestUrlGeneral(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
 export declare const ingestUrlInputSchema: z.ZodObject<{
     portfolio_id: z.ZodString;
     url: z.ZodString;
     program_id: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    portfolio_id: string;
     url: string;
+    portfolio_id: string;
     program_id: string;
 }, {
-    portfolio_id: string;
     url: string;
+    portfolio_id: string;
     program_id: string;
 }>;
 export type IngestUrlInput = z.infer<typeof ingestUrlInputSchema>;
@@ -137,3 +190,4 @@ export declare function handleIngestUrl(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare function registerIngestTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;