@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/annotations.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Annotation tools:
+ *   tacit_annotate         — POST /api/v1/artifacts/:id/annotations
+ *   tacit_list_annotations — GET  /api/v1/artifacts/:id/annotations
+ */
+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 ANNOTATION_TYPES: readonly ["DELETION", "COMMENT", "GLOBAL_COMMENT", "CORRECTION", "APPROVE", "FACTUAL_CORRECTION", "OUTDATED_FLAG", "QUALITY_RATING", "NEEDS_REVIEW"];
+export declare const annotateInputSchema: z.ZodObject<{
+    artifact_id: z.ZodString;
+    annotation_type: z.ZodEnum<["DELETION", "COMMENT", "GLOBAL_COMMENT", "CORRECTION", "APPROVE", "FACTUAL_CORRECTION", "OUTDATED_FLAG", "QUALITY_RATING", "NEEDS_REVIEW"]>;
+    annotation_text: z.ZodOptional<z.ZodString>;
+    original_text: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    block_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    trust_modifier: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    artifact_id: string;
+    annotation_type: "DELETION" | "COMMENT" | "GLOBAL_COMMENT" | "CORRECTION" | "APPROVE" | "FACTUAL_CORRECTION" | "OUTDATED_FLAG" | "QUALITY_RATING" | "NEEDS_REVIEW";
+    original_text: string;
+    block_id: string;
+    annotation_text?: string | undefined;
+    trust_modifier?: number | undefined;
+}, {
+    artifact_id: string;
+    annotation_type: "DELETION" | "COMMENT" | "GLOBAL_COMMENT" | "CORRECTION" | "APPROVE" | "FACTUAL_CORRECTION" | "OUTDATED_FLAG" | "QUALITY_RATING" | "NEEDS_REVIEW";
+    annotation_text?: string | undefined;
+    original_text?: string | undefined;
+    block_id?: string | undefined;
+    trust_modifier?: number | undefined;
+}>;
+export type AnnotateInput = z.infer<typeof annotateInputSchema>;
+export declare const ANNOTATE_TOOL_DEF: {
+    name: "tacit_annotate";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            artifact_id: {
+                type: string;
+                description: string;
+            };
+            annotation_type: {
+                type: string;
+                enum: readonly ["DELETION", "COMMENT", "GLOBAL_COMMENT", "CORRECTION", "APPROVE", "FACTUAL_CORRECTION", "OUTDATED_FLAG", "QUALITY_RATING", "NEEDS_REVIEW"];
+                description: string;
+            };
+            annotation_text: {
+                type: string;
+                description: string;
+            };
+            original_text: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            block_id: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            trust_modifier: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildAnnotateRequest(client: TacitClient, input: AnnotateInput): ToolRequest;
+export declare function handleAnnotate(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const listAnnotationsInputSchema: z.ZodObject<{
+    artifact_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    artifact_id: string;
+}, {
+    artifact_id: string;
+}>;
+export type ListAnnotationsInput = z.infer<typeof listAnnotationsInputSchema>;
+export declare const LIST_ANNOTATIONS_TOOL_DEF: {
+    name: "tacit_list_annotations";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            artifact_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildListAnnotationsRequest(client: TacitClient, input: ListAnnotationsInput): ToolRequest;
+export declare function handleListAnnotations(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function registerAnnotationTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/annotations.js

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Annotation tools:
+ *   tacit_annotate         — POST /api/v1/artifacts/:id/annotations
+ *   tacit_list_annotations — GET  /api/v1/artifacts/:id/annotations
+ */
+import { z } from 'zod';
+import { getClient } from '../client.js';
+import { apiErrorResult } from './errors.js';
+// ─── tacit_annotate ───────────────────────────────────────────────────────────
+export const ANNOTATION_TYPES = [
+    'DELETION',
+    'COMMENT',
+    'GLOBAL_COMMENT',
+    'CORRECTION',
+    'APPROVE',
+    'FACTUAL_CORRECTION',
+    'OUTDATED_FLAG',
+    'QUALITY_RATING',
+    'NEEDS_REVIEW',
+];
+export const annotateInputSchema = z.object({
+    artifact_id: z.string().min(1).describe('Artifact UUID to annotate'),
+    annotation_type: z.enum(ANNOTATION_TYPES).describe('Type of annotation'),
+    annotation_text: z.string().optional().describe('Annotation text/comment'),
+    original_text: z.string().optional().default('').describe('Original text being annotated'),
+    block_id: z.string().optional().default('').describe('Block identifier within the artifact'),
+    trust_modifier: z.number().optional().describe('Trust score modifier'),
+});
+export const ANNOTATE_TOOL_DEF = {
+    name: 'tacit_annotate',
+    description: 'Create an annotation on an artifact. Route: POST /api/v1/artifacts/:id/annotations.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            artifact_id: { type: 'string', description: 'Artifact UUID' },
+            annotation_type: { type: 'string', enum: ANNOTATION_TYPES, description: 'Annotation type' },
+            annotation_text: { type: 'string', description: 'Annotation text/comment' },
+            original_text: { type: 'string', description: 'Original text being annotated', default: '' },
+            block_id: { type: 'string', description: 'Block identifier within the artifact', default: '' },
+            trust_modifier: { type: 'number', description: 'Trust score modifier' },
+        },
+        required: ['artifact_id', 'annotation_type'],
+    },
+};
+export function buildAnnotateRequest(client, input) {
+    return {
+        async execute() {
+            const { artifact_id, annotation_type, annotation_text, original_text, block_id, trust_modifier } = input;
+            try {
+                const body = {
+                    annotation_type,
+                    original_text,
+                    block_id,
+                };
+                if (annotation_text !== undefined)
+                    body['annotation_text'] = annotation_text;
+                if (trust_modifier !== undefined)
+                    body['trust_modifier'] = trust_modifier;
+                const result = await client.post(`/api/v1/artifacts/${artifact_id}/annotations`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, `/api/v1/artifacts/:id/annotations`);
+            }
+        },
+    };
+}
+export async function handleAnnotate(args) {
+    const parsed = annotateInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildAnnotateRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_list_annotations ───────────────────────────────────────────────────
+export const listAnnotationsInputSchema = z.object({
+    artifact_id: z.string().min(1).describe('Artifact UUID'),
+});
+export const LIST_ANNOTATIONS_TOOL_DEF = {
+    name: 'tacit_list_annotations',
+    description: 'List annotations on an artifact. Route: GET /api/v1/artifacts/:id/annotations.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            artifact_id: { type: 'string', description: 'Artifact UUID' },
+        },
+        required: ['artifact_id'],
+    },
+};
+export function buildListAnnotationsRequest(client, input) {
+    return {
+        async execute() {
+            const { artifact_id } = input;
+            try {
+                const result = await client.get(`/api/v1/artifacts/${artifact_id}/annotations`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, `/api/v1/artifacts/:id/annotations`);
+            }
+        },
+    };
+}
+export async function handleListAnnotations(args) {
+    const parsed = listAnnotationsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListAnnotationsRequest(getClient(), parsed.data).execute();
+}
+export function registerAnnotationTools(server, getClientFn) {
+    server.tool('tacit_annotate', 'Create an annotation on an artifact. Route: POST /api/v1/artifacts/:id/annotations.', {
+        artifact_id: z.string().min(1).describe('Artifact UUID to annotate'),
+        annotation_type: z.enum(ANNOTATION_TYPES).describe('Type of annotation'),
+        annotation_text: z.string().optional().describe('Annotation text/comment'),
+        original_text: z.string().optional().default('').describe('Original text being annotated'),
+        block_id: z.string().optional().default('').describe('Block identifier within the artifact'),
+        trust_modifier: z.number().optional().describe('Trust score modifier'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildAnnotateRequest(client, args).execute();
+    });
+    server.tool('tacit_list_annotations', 'List annotations on an artifact. Route: GET /api/v1/artifacts/:id/annotations.', {
+        artifact_id: z.string().min(1).describe('Artifact UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildListAnnotationsRequest(client, args).execute();
+    });
+}

package/dist/tools/artifacts.d.ts

@@ -1,7 +1,7 @@
 /**
  * Artifact tools:
  *   tacit_artifact_list    — GET  /api/v1/artifacts
- *   tacit_artifact_create  — POST /api/v1/artifacts  (career-scoped handler)
+ *   tacit_artifact_create  — POST /api/v1/artifacts
  *   tacit_artifact_update  — PATCH /api/v1/artifacts/:id
  *   tacit_artifact_publish — POST  /api/v1/artifacts/:id/publish
  *
@@ -14,9 +14,10 @@
  *   - artifact_kind is hardcoded server-side (GENERIC) — the client must NOT send it.
  *   - The artifact body is populated server-side from structured_metadata
  *     (e.g. full_posting_text); the client does NOT send a content field.
- *   - This tool always sends "domain":"CAREER" in the request body.
+ *   - domain defaults to GENERAL if omitted; caller may pass any valid domain.
  */
 import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { TacitClient } from '../client.js';
 export interface ToolRequest {
     execute(): Promise<{
@@ -28,16 +29,25 @@ export interface ToolRequest {
     }>;
 }
 export declare const artifactListInputSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<["IMPORTED", "SYNTHESIZED", "WIKI_CONVERGENCE"]>>;
+    status: z.ZodOptional<z.ZodString>;
+    portfolio_id: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
-    status: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     limit?: number | undefined;
     status?: string | undefined;
+    origin?: "IMPORTED" | "SYNTHESIZED" | "WIKI_CONVERGENCE" | undefined;
+    q?: string | undefined;
+    portfolio_id?: string | undefined;
     offset?: number | undefined;
 }, {
     limit?: number | undefined;
     status?: string | undefined;
+    origin?: "IMPORTED" | "SYNTHESIZED" | "WIKI_CONVERGENCE" | undefined;
+    q?: string | undefined;
+    portfolio_id?: string | undefined;
     offset?: number | undefined;
 }>;
 export type ArtifactListInput = z.infer<typeof artifactListInputSchema>;
@@ -47,18 +57,29 @@ export declare const ARTIFACT_LIST_TOOL_DEF: {
     inputSchema: {
         type: "object";
         properties: {
-            limit: {
+            q: {
                 type: string;
                 description: string;
             };
-            offset: {
+            origin: {
                 type: string;
-                description: string;
+                enum: string[];
             };
             status: {
                 type: string;
                 description: string;
             };
+            portfolio_id: {
+                type: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
         };
         required: never[];
     };
@@ -77,13 +98,13 @@ export declare const artifactCreateInputSchema: z.ZodObject<{
     portfolio_id: z.ZodString;
     structured_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    portfolio_id: string;
     title: string;
+    portfolio_id: string;
     domain?: string | undefined;
     structured_metadata?: Record<string, unknown> | undefined;
 }, {
-    portfolio_id: string;
     title: string;
+    portfolio_id: string;
     domain?: string | undefined;
     structured_metadata?: Record<string, unknown> | undefined;
 }>;
@@ -206,3 +227,152 @@ export declare function handleArtifactPublish(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare const artifactGetInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type ArtifactGetInput = z.infer<typeof artifactGetInputSchema>;
+export declare const ARTIFACT_GET_TOOL_DEF: {
+    name: "tacit_artifact_get";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactGetRequest(client: TacitClient, input: ArtifactGetInput): ToolRequest;
+export declare function handleArtifactGet(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactReviseInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    if_match: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title?: string | undefined;
+    if_match?: string | undefined;
+}, {
+    id: string;
+    title?: string | undefined;
+    if_match?: string | undefined;
+}>;
+export type ArtifactReviseInput = z.infer<typeof artifactReviseInputSchema>;
+export declare const ARTIFACT_REVISE_TOOL_DEF: {
+    name: "tacit_artifact_revise";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            if_match: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactReviseRequest(client: TacitClient, input: ArtifactReviseInput): ToolRequest;
+export declare function handleArtifactRevise(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactVersionsInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type ArtifactVersionsInput = z.infer<typeof artifactVersionsInputSchema>;
+export declare const ARTIFACT_VERSIONS_TOOL_DEF: {
+    name: "tacit_artifact_versions";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactVersionsRequest(client: TacitClient, input: ArtifactVersionsInput): ToolRequest;
+export declare function handleArtifactVersions(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const artifactDeleteInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    confirm: z.ZodBoolean;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    confirm: boolean;
+    force?: boolean | undefined;
+}, {
+    id: string;
+    confirm: boolean;
+    force?: boolean | undefined;
+}>;
+export type ArtifactDeleteInput = z.infer<typeof artifactDeleteInputSchema>;
+export declare const ARTIFACT_DELETE_TOOL_DEF: {
+    name: "tacit_artifact_delete";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            confirm: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildArtifactDeleteRequest(client: TacitClient, input: ArtifactDeleteInput): ToolRequest;
+export declare function handleArtifactDelete(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function registerArtifactTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;