@iflow-mcp/andrewhopper-facts-server 1.0.0

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { PrismaStorageProvider } from './storage.js';
+import { validateCriteria } from './validation.js';
+import { StrictnessLevel, FactCategory } from './types.js';
+class FactsServer {
+    constructor() {
+        this.storage = new PrismaStorageProvider();
+        this.server = new Server({
+            name: 'facts-server',
+            version: '0.1.0',
+        }, {
+            capabilities: {
+                tools: {
+                    get_all_facts: {
+                        description: 'Get all facts in the system',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    },
+                    get_fact: {
+                        description: 'Get a fact by ID',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    description: 'The ID of the fact to retrieve'
+                                }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    search_facts: {
+                        description: 'Search facts by type, strictness, and version',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    description: 'Filter by fact type'
+                                },
+                                strictness: {
+                                    type: 'string',
+                                    enum: Object.values(StrictnessLevel),
+                                    description: 'Filter by strictness level'
+                                },
+                                version: {
+                                    type: 'string',
+                                    description: 'Filter by version compatibility'
+                                }
+                            }
+                        }
+                    },
+                    set_fact: {
+                        description: 'Create or update a fact',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string' },
+                                content: { type: 'string' },
+                                strictness: {
+                                    type: 'string',
+                                    enum: Object.values(StrictnessLevel)
+                                },
+                                type: { type: 'string' },
+                                category: {
+                                    type: 'string',
+                                    enum: Object.values(FactCategory),
+                                    description: 'The category this fact belongs to'
+                                },
+                                minVersion: { type: 'string' },
+                                maxVersion: { type: 'string' },
+                                conditions: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            factId: { type: 'string' },
+                                            type: {
+                                                type: 'string',
+                                                enum: ['REQUIRES', 'CONFLICTS_WITH']
+                                            }
+                                        },
+                                        required: ['factId', 'type']
+                                    }
+                                },
+                                acceptanceCriteria: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            id: { type: 'string' },
+                                            description: { type: 'string' },
+                                            validationType: {
+                                                type: 'string',
+                                                enum: ['MANUAL', 'AUTOMATED']
+                                            },
+                                            validationScript: { type: 'string' }
+                                        },
+                                        required: ['id', 'description', 'validationType']
+                                    }
+                                }
+                            },
+                            required: ['id', 'content', 'strictness', 'type', 'category', 'minVersion', 'maxVersion']
+                        }
+                    },
+                    validate_criteria: {
+                        description: 'Validate content against fact acceptance criteria',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                factId: {
+                                    type: 'string',
+                                    description: 'ID of the fact to validate against'
+                                },
+                                content: {
+                                    type: 'string',
+                                    description: 'Content to validate'
+                                }
+                            },
+                            required: ['factId', 'content']
+                        }
+                    }
+                }
+            }
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // Handler for listing available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'get_all_facts',
+                    description: 'Get all facts in the system',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {}
+                    }
+                },
+                {
+                    name: 'get_fact',
+                    description: 'Get a fact by ID',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: 'string',
+                                description: 'The ID of the fact to retrieve'
+                            }
+                        },
+                        required: ['id']
+                    }
+                },
+                {
+                    name: 'search_facts',
+                    description: 'Search facts by type, strictness, and version',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                description: 'Filter by fact type'
+                            },
+                            strictness: {
+                                type: 'string',
+                                enum: Object.values(StrictnessLevel),
+                                description: 'Filter by strictness level'
+                            },
+                            version: {
+                                type: 'string',
+                                description: 'Filter by version compatibility'
+                            }
+                        }
+                    }
+                },
+                {
+                    name: 'set_fact',
+                    description: 'Create or update a fact',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                            content: { type: 'string' },
+                            strictness: {
+                                type: 'string',
+                                enum: Object.values(StrictnessLevel)
+                            },
+                            type: { type: 'string' },
+                            category: {
+                                type: 'string',
+                                enum: Object.values(FactCategory),
+                                description: 'The category this fact belongs to'
+                            },
+                            minVersion: { type: 'string' },
+                            maxVersion: { type: 'string' },
+                            conditions: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        factId: { type: 'string' },
+                                        type: {
+                                            type: 'string',
+                                            enum: ['REQUIRES', 'CONFLICTS_WITH']
+                                        }
+                                    },
+                                    required: ['factId', 'type']
+                                }
+                            },
+                            acceptanceCriteria: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string' },
+                                        description: { type: 'string' },
+                                        validationType: {
+                                            type: 'string',
+                                            enum: ['MANUAL', 'AUTOMATED']
+                                        },
+                                        validationScript: { type: 'string' }
+                                    },
+                                    required: ['id', 'description', 'validationType']
+                                }
+                            }
+                        },
+                        required: ['id', 'content', 'strictness', 'type', 'category', 'minVersion', 'maxVersion']
+                    }
+                },
+                {
+                    name: 'validate_criteria',
+                    description: 'Validate content against fact acceptance criteria',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            factId: {
+                                type: 'string',
+                                description: 'ID of the fact to validate against'
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'Content to validate'
+                            }
+                        },
+                        required: ['factId', 'content']
+                    }
+                }
+            ]
+        }));
+        // Handler for executing tools
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            switch (request.params.name) {
+                case 'get_all_facts': {
+                    const facts = await this.storage.searchFacts({});
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(facts, null, 2) }]
+                    };
+                }
+                case 'get_fact': {
+                    const args = request.params.arguments;
+                    const fact = await this.storage.getFact(args.id);
+                    if (!fact) {
+                        return {
+                            content: [{ type: 'text', text: `Fact not found: ${args.id}` }],
+                            isError: true
+                        };
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(fact, null, 2) }]
+                    };
+                }
+                case 'search_facts': {
+                    const args = request.params.arguments;
+                    const facts = await this.storage.searchFacts(args);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(facts, null, 2) }]
+                    };
+                }
+                case 'set_fact': {
+                    const args = request.params.arguments;
+                    try {
+                        await this.storage.setFact(args.id, args.content, args.strictness, args.type, args.category, args.minVersion, args.maxVersion, args.conditions || [], args.acceptanceCriteria || []);
+                        return {
+                            content: [{ type: 'text', text: `Fact ${args.id} saved successfully` }]
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            content: [{ type: 'text', text: `Error saving fact: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+                            isError: true
+                        };
+                    }
+                }
+                case 'validate_criteria': {
+                    const args = request.params.arguments;
+                    const fact = await this.storage.getFact(args.factId);
+                    if (!fact) {
+                        return {
+                            content: [{ type: 'text', text: `Fact not found: ${args.factId}` }],
+                            isError: true
+                        };
+                    }
+                    try {
+                        const results = await validateCriteria(args.content, fact.acceptanceCriteria);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }]
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            content: [{ type: 'text', text: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+                            isError: true
+                        };
+                    }
+                }
+            }
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Facts MCP server running on stdio');
+        // Handle cleanup on shutdown
+        process.on('SIGINT', async () => {
+            await this.storage.close();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            await this.storage.close();
+            process.exit(0);
+        });
+    }
+}
+const server = new FactsServer();
+server.run().catch(console.error);

package/build/sdk/server.d.ts

@@ -0,0 +1,13 @@
+import { ServerRequest, ServerResponse, ServerInfo, ServerCapabilities, ServerTransport } from './types.js';
+export declare class Server {
+    private info;
+    private capabilities;
+    private transport;
+    private handlers;
+    constructor(info: ServerInfo, capabilities: {
+        capabilities: ServerCapabilities;
+    });
+    connect(transport: ServerTransport): Promise<void>;
+    close(): Promise<void>;
+    setHandler(method: string, handler: (request: ServerRequest) => Promise<ServerResponse>): void;
+}

package/build/sdk/server.js

@@ -0,0 +1,31 @@
+export class Server {
+    constructor(info, capabilities) {
+        this.info = info;
+        this.capabilities = capabilities;
+        this.transport = null;
+        this.handlers = new Map();
+    }
+    async connect(transport) {
+        this.transport = transport;
+        transport.onRequest(async (request) => {
+            const handler = this.handlers.get(request.method);
+            if (!handler) {
+                return {
+                    content: [{ type: 'text', text: `Unknown method: ${request.method}` }],
+                    isError: true
+                };
+            }
+            return handler(request);
+        });
+        await transport.connect();
+    }
+    async close() {
+        if (this.transport) {
+            await this.transport.disconnect();
+            this.transport = null;
+        }
+    }
+    setHandler(method, handler) {
+        this.handlers.set(method, handler);
+    }
+}

package/build/sdk/stdio.d.ts

@@ -0,0 +1,8 @@
+import { ServerRequest, ServerResponse, ServerTransport } from './types.js';
+export declare class StdioServerTransport implements ServerTransport {
+    private requestHandler;
+    private readline;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onRequest(handler: (request: ServerRequest) => Promise<ServerResponse>): void;
+}

package/build/sdk/stdio.js

@@ -0,0 +1,34 @@
+import { createInterface } from 'readline';
+export class StdioServerTransport {
+    constructor() {
+        this.requestHandler = null;
+        this.readline = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+    async connect() {
+        this.readline.on('line', async (line) => {
+            try {
+                const request = JSON.parse(line);
+                if (this.requestHandler) {
+                    const response = await this.requestHandler(request);
+                    console.log(JSON.stringify(response));
+                }
+            }
+            catch (error) {
+                console.error('Error processing request:', error);
+                console.log(JSON.stringify({
+                    content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+                    isError: true
+                }));
+            }
+        });
+    }
+    async disconnect() {
+        this.readline.close();
+    }
+    onRequest(handler) {
+        this.requestHandler = handler;
+    }
+}

package/build/sdk/types.d.ts

@@ -0,0 +1,30 @@
+export interface ServerRequest {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface ServerResponse {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface ServerCapabilities {
+    tools?: Record<string, {
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    }>;
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+export interface ServerTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onRequest(handler: (request: ServerRequest) => Promise<ServerResponse>): void;
+}

package/build/sdk/types.js

@@ -0,0 +1 @@
+export {};

package/build/storage.d.ts

@@ -0,0 +1,17 @@
+import { StorageProvider, StorageSearchResult, StrictnessLevel, FactCategory, Condition, AcceptanceCriterion } from './types.js';
+export declare class PrismaStorageProvider implements StorageProvider {
+    private prisma;
+    constructor();
+    setFact(id: string, content: string, strictness: StrictnessLevel, type: string, category: FactCategory, minVersion: string, maxVersion: string, conditions: Condition[], acceptanceCriteria: AcceptanceCriterion[], contentEmbedding?: string): Promise<void>;
+    getFact(id: string): Promise<StorageSearchResult | null>;
+    searchFacts(options: {
+        type?: string;
+        category?: FactCategory;
+        strictness?: StrictnessLevel;
+        version?: string;
+        embedding?: string;
+        similarityThreshold?: number;
+    }): Promise<StorageSearchResult[]>;
+    deleteFact(id: string): Promise<boolean>;
+    close(): Promise<void>;
+}

package/build/storage.js

@@ -0,0 +1,193 @@
+import { PrismaClient } from '@prisma/client';
+export class PrismaStorageProvider {
+    constructor() {
+        this.prisma = new PrismaClient();
+    }
+    async setFact(id, content, strictness, type, category, minVersion, maxVersion, conditions, acceptanceCriteria, contentEmbedding) {
+        const data = {
+            id,
+            content,
+            strictness,
+            type,
+            category,
+            minVersion,
+            maxVersion,
+            content_embedding: contentEmbedding,
+            conditions: {
+                create: conditions.map(condition => ({
+                    type: condition.type,
+                    targetId: condition.factId
+                }))
+            },
+            acceptanceCriteria: {
+                create: acceptanceCriteria.map(criterion => ({
+                    id: criterion.id,
+                    description: criterion.description,
+                    validationType: criterion.validationType,
+                    validationScript: criterion.validationScript
+                }))
+            }
+        };
+        await this.prisma.fact.upsert({
+            where: { id },
+            create: data,
+            update: {
+                ...data,
+                conditions: {
+                    deleteMany: {},
+                    create: conditions.map(condition => ({
+                        type: condition.type,
+                        targetId: condition.factId
+                    }))
+                },
+                acceptanceCriteria: {
+                    deleteMany: {},
+                    create: acceptanceCriteria.map(criterion => ({
+                        id: criterion.id,
+                        description: criterion.description,
+                        validationType: criterion.validationType,
+                        validationScript: criterion.validationScript
+                    }))
+                }
+            }
+        });
+    }
+    async getFact(id) {
+        const fact = await this.prisma.fact.findUnique({
+            where: { id },
+            include: {
+                conditions: true,
+                acceptanceCriteria: true
+            }
+        });
+        if (!fact) {
+            return null;
+        }
+        return {
+            id: fact.id,
+            content: fact.content,
+            strictness: fact.strictness,
+            type: fact.type,
+            category: fact.category,
+            minVersion: fact.minVersion,
+            maxVersion: fact.maxVersion,
+            conditions: fact.conditions.map(c => ({
+                factId: c.targetId,
+                type: c.type
+            })),
+            acceptanceCriteria: fact.acceptanceCriteria.map(ac => ({
+                id: ac.id,
+                description: ac.description,
+                validationType: ac.validationType,
+                validationScript: ac.validationScript || undefined
+            })),
+            createdAt: fact.createdAt.toISOString(),
+            updatedAt: fact.updatedAt.toISOString(),
+            applicable: fact.applicable
+        };
+    }
+    async searchFacts(options) {
+        let facts;
+        if (options.embedding) {
+            // Use raw query for vector similarity search
+            const threshold = options.similarityThreshold || 0.8;
+            const whereConditions = [];
+            const params = [options.embedding, threshold];
+            if (options.type) {
+                whereConditions.push('f.type = ?');
+                params.push(options.type);
+            }
+            if (options.category) {
+                whereConditions.push('f.category = ?');
+                params.push(options.category);
+            }
+            if (options.strictness) {
+                whereConditions.push('f.strictness = ?');
+                params.push(options.strictness);
+            }
+            if (options.version) {
+                whereConditions.push('f.minVersion <= ? AND f.maxVersion >= ?');
+                params.push(options.version, options.version);
+            }
+            const whereClause = whereConditions.length
+                ? 'AND ' + whereConditions.join(' AND ')
+                : '';
+            const rawResults = await this.prisma.$queryRawUnsafe(`SELECT f.*, 
+                       vector_similarity(f.content_embedding, ?) as similarity
+                FROM "Fact" f
+                WHERE vector_similarity(f.content_embedding, ?) > ?
+                ${whereClause}
+                ORDER BY similarity DESC`, options.embedding, options.embedding, threshold, ...params);
+            // Fetch full fact data including relations
+            const factPromises = rawResults.map(result => this.prisma.fact.findUnique({
+                where: { id: result.id },
+                include: {
+                    conditions: true,
+                    acceptanceCriteria: true
+                }
+            }));
+            facts = (await Promise.all(factPromises)).filter((fact) => fact !== null);
+        }
+        else {
+            const where = {};
+            if (options.type) {
+                where.type = options.type;
+            }
+            if (options.category) {
+                where.category = options.category;
+            }
+            if (options.strictness) {
+                where.strictness = options.strictness;
+            }
+            if (options.version) {
+                where.AND = [
+                    { minVersion: { lte: options.version } },
+                    { maxVersion: { gte: options.version } }
+                ];
+            }
+            facts = await this.prisma.fact.findMany({
+                where,
+                include: {
+                    conditions: true,
+                    acceptanceCriteria: true
+                }
+            });
+        }
+        return facts.map(fact => ({
+            id: fact.id,
+            content: fact.content,
+            strictness: fact.strictness,
+            type: fact.type,
+            category: fact.category,
+            minVersion: fact.minVersion,
+            maxVersion: fact.maxVersion,
+            conditions: fact.conditions.map(c => ({
+                factId: c.targetId,
+                type: c.type
+            })),
+            acceptanceCriteria: fact.acceptanceCriteria.map(ac => ({
+                id: ac.id,
+                description: ac.description,
+                validationType: ac.validationType,
+                validationScript: ac.validationScript || undefined
+            })),
+            createdAt: fact.createdAt.toISOString(),
+            updatedAt: fact.updatedAt.toISOString(),
+            applicable: fact.applicable
+        }));
+    }
+    async deleteFact(id) {
+        try {
+            await this.prisma.fact.delete({
+                where: { id }
+            });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async close() {
+        await this.prisma.$disconnect();
+    }
+}