@kubun/mcp 0.10.0 → 0.11.0

package/lib/client.d.ts

@@ -1,4 +1,4 @@
-import { type SigningIdentity } from '@enkaku/token';
+import { type SigningIdentity } from '@kokuin/token';
 import type { GraphsProvider } from '@kubun/protocol';
 export type ClientConfig = {
     type: 'memory';

package/lib/client.js

@@ -1 +1,79 @@
-import{randomIdentity as t}from"@enkaku/token";import{KubunDB as e}from"@kubun/db";import{NodeSQLiteAdapter as r}from"@kubun/db-node-sqlite";import{PostgresAdapter as p}from"@kubun/db-postgres";import{KubunEngine as s}from"@kubun/engine";import{HTTPClient as o}from"@kubun/http-client";export function parseDatabase(t){return t.startsWith("http://")||t.startsWith("https://")?{type:"http",url:t}:t.startsWith("postgres://")?{type:"postgres",url:t}:":memory:"===t?{type:"memory"}:{type:"sqlite",path:t}}export async function createConnection(n){let i=n.identity??t(),a=function(t){switch(t.type){case"http":case"postgres":return t.url;case"sqlite":return t.path;case"memory":return":memory:"}}(n);if("http"===n.type)return{provider:new o({identity:i,serverID:n.serverID,url:n.url}),dispose:async()=>{},type:"http",address:a};let u=new e({adapter:"postgres"===n.type?new p({url:n.url}):new r({database:"sqlite"===n.type?n.path:":memory:"})}),m=new s({db:u,identity:i,plugins:[]});return{provider:m,dispose:async()=>{await m.dispose(),await u.close()},type:n.type,address:a}}
+import { randomIdentity } from '@kokuin/token';
+import { KubunDB } from '@kubun/db';
+import { NodeSQLiteAdapter } from '@kubun/db-node-sqlite';
+import { PostgresAdapter } from '@kubun/db-postgres';
+import { KubunEngine } from '@kubun/engine';
+import { HTTPClient } from '@kubun/http-client';
+export function parseDatabase(database) {
+    if (database.startsWith('http://') || database.startsWith('https://')) {
+        return {
+            type: 'http',
+            url: database
+        };
+    }
+    if (database.startsWith('postgres://')) {
+        return {
+            type: 'postgres',
+            url: database
+        };
+    }
+    if (database === ':memory:') {
+        return {
+            type: 'memory'
+        };
+    }
+    return {
+        type: 'sqlite',
+        path: database
+    };
+}
+function getAddress(config) {
+    switch(config.type){
+        case 'http':
+            return config.url;
+        case 'postgres':
+            return config.url;
+        case 'sqlite':
+            return config.path;
+        case 'memory':
+            return ':memory:';
+    }
+}
+export async function createConnection(params) {
+    const identity = params.identity ?? randomIdentity();
+    const address = getAddress(params);
+    if (params.type === 'http') {
+        return {
+            provider: new HTTPClient({
+                identity,
+                serverID: params.serverID,
+                url: params.url
+            }),
+            dispose: async ()=>{},
+            type: 'http',
+            address
+        };
+    }
+    const adapter = params.type === 'postgres' ? new PostgresAdapter({
+        url: params.url
+    }) : new NodeSQLiteAdapter({
+        database: params.type === 'sqlite' ? params.path : ':memory:'
+    });
+    const db = new KubunDB({
+        adapter
+    });
+    const engine = new KubunEngine({
+        db,
+        identity,
+        plugins: []
+    });
+    return {
+        provider: engine,
+        dispose: async ()=>{
+            await engine.dispose();
+            await db.close();
+        },
+        type: params.type,
+        address
+    };
+}

package/lib/config.d.ts

@@ -1,4 +1,4 @@
-import type { SigningIdentity } from '@enkaku/token';
+import type { SigningIdentity } from '@kokuin/token';
 import type { ServerConfig } from '@mokei/context-server';
 export type MCPConfig = {
     connect?: string;

package/lib/config.js

@@ -1 +1,40 @@
-import{createConnection as t,parseDatabase as n}from"./client.js";import{prompts as o}from"./prompts/index.js";import{createClusterTools as e}from"./tools/cluster.js";import{createConnectionTools as i}from"./tools/connection.js";import{createGraphTools as r}from"./tools/graph.js";export async function createConfig(l={}){let s=null!=l.connect?{type:"http",url:l.connect,identity:l.identity}:null!=l.database?{...n(l.database),identity:l.identity}:null,a={current:null!=s?await t(s):null},c=i(a,l.identity),m=e(a),u=r(a);return{name:"kubun",version:"0.1.0",prompts:o,tools:{...c,...m,...u}}}
+import { createConnection, parseDatabase } from './client.js';
+import { prompts } from './prompts/index.js';
+import { createClusterTools } from './tools/cluster.js';
+import { createConnectionTools } from './tools/connection.js';
+import { createGraphTools } from './tools/graph.js';
+function parseConfig(config) {
+    if (config.connect != null) {
+        return {
+            type: 'http',
+            url: config.connect,
+            identity: config.identity
+        };
+    }
+    if (config.database != null) {
+        return {
+            ...parseDatabase(config.database),
+            identity: config.identity
+        };
+    }
+    return null;
+}
+export async function createConfig(config = {}) {
+    const params = parseConfig(config);
+    const container = {
+        current: params != null ? await createConnection(params) : null
+    };
+    const connectionTools = createConnectionTools(container, config.identity);
+    const clusterTools = createClusterTools(container);
+    const graphTools = createGraphTools(container);
+    return {
+        name: 'kubun',
+        version: '0.1.0',
+        prompts,
+        tools: {
+            ...connectionTools,
+            ...clusterTools,
+            ...graphTools
+        }
+    };
+}

package/lib/container.js

@@ -1 +1,14 @@
-export function getProvider(t){return t.current?.provider??null}export function notConnectedError(){return{isError:!0,content:[{type:"text",text:"No database connected. Use the connect tool first."}]}}
+export function getProvider(container) {
+    return container.current?.provider ?? null;
+}
+export function notConnectedError() {
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: 'No database connected. Use the connect tool first.'
+            }
+        ]
+    };
+}

package/lib/index.js

@@ -1 +1,2 @@
-export{createConnection,parseDatabase}from"./client.js";export{createConfig}from"./config.js";
+export { createConnection, parseDatabase } from './client.js';
+export { createConfig } from './config.js';

package/lib/prompts/data-model-designer.js

@@ -1,4 +1,4 @@
-export const KUBUN_PROMPT_INSTRUCTIONS=`# Kubun Protocol Data Model Generator
+export const KUBUN_PROMPT_INSTRUCTIONS = `# Kubun Protocol Data Model Generator
 
 You are an expert at creating data models following the Kubun protocol specification. Your task is to generate valid JSON schemas for data models based on user requirements.
 
@@ -612,4 +612,4 @@ When generating a model cluster, organize models in this order:
 
 ## Response Format
 
-Always generate models as a JSON array, even when a single model is needed. Validate that your output follows the specification exactly.`;
+Always generate models as a JSON array, even when a single model is needed. Validate that your output follows the specification exactly.`;

package/lib/prompts/index.js

@@ -1 +1,19 @@
-import{KUBUN_PROMPT_INSTRUCTIONS as e}from"./data-model-designer.js";export const prompts={"data-model-designer":{description:"Instructions to help design a data model following the Kubun protocol specification",handler:()=>({messages:[{role:"user",content:{type:"text",text:e}}]})}};
+import { KUBUN_PROMPT_INSTRUCTIONS } from './data-model-designer.js';
+export const prompts = {
+    'data-model-designer': {
+        description: 'Instructions to help design a data model following the Kubun protocol specification',
+        handler: ()=>{
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: KUBUN_PROMPT_INSTRUCTIONS
+                        }
+                    }
+                ]
+            };
+        }
+    }
+};

package/lib/run.js

@@ -1,2 +1,19 @@
 #!/usr/bin/env node
-import{parseArgs as t}from"node:util";import{serveProcess as e}from"@mokei/context-server";import{createConfig as o}from"./config.js";let n=t({options:{connect:{type:"string"},db:{type:"string"}}});e(await o({connect:n.values.connect,database:n.values.db}));
+import { parseArgs } from 'node:util';
+import { serveProcess } from '@mokei/context-server';
+import { createConfig } from './config.js';
+const args = parseArgs({
+    options: {
+        connect: {
+            type: 'string'
+        },
+        db: {
+            type: 'string'
+        }
+    }
+});
+const config = await createConfig({
+    connect: args.values.connect,
+    database: args.values.db
+});
+serveProcess(config);

package/lib/tools/cluster.js

@@ -1 +1,79 @@
-import{ClusterBuilder as e,clusterModel as t}from"@kubun/protocol";import{createTool as r}from"@mokei/context-server";import{getProvider as s,notConnectedError as o}from"../container.js";export function createClusterTools(n){return{create_cluster:r("Create a new cluster from model definitions",{type:"object",properties:{models:{type:"array",items:{type:"object"}}},required:["models"],additionalProperties:!1},async t=>{let r=new e;return r.addAll(t.arguments.models),{content:[{type:"text",text:"Cluster created"}],structuredContent:{cluster:r.build()}}}),deploy_clusters:r("Deploy clusters to the Kubun backend",{type:"object",properties:{clusters:{type:"array",items:t},id:{type:"string"},name:{type:"string"}},required:["clusters"],additionalProperties:!1},async e=>{let t=s(n);if(null==t)return o();let r=await t.deployGraph({clusters:e.arguments.clusters,id:e.arguments.id,name:e.arguments.name});return{content:[{type:"text",text:`Clusters deployed to graph "${r.id}"`}],structuredContent:{id:r.id,record:r.record,aliases:r.aliases}}})}}
+import { ClusterBuilder, clusterModel } from '@kubun/protocol';
+import { createTool } from '@mokei/context-server';
+import { getProvider, notConnectedError } from '../container.js';
+export function createClusterTools(container) {
+    const create_cluster = createTool('Create a new cluster from model definitions', {
+        type: 'object',
+        properties: {
+            models: {
+                type: 'array',
+                items: {
+                    type: 'object'
+                }
+            }
+        },
+        required: [
+            'models'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const builder = new ClusterBuilder();
+        builder.addAll(ctx.arguments.models);
+        const cluster = builder.build();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Cluster created'
+                }
+            ],
+            structuredContent: {
+                cluster
+            }
+        };
+    });
+    const deploy_clusters = createTool('Deploy clusters to the Kubun backend', {
+        type: 'object',
+        properties: {
+            clusters: {
+                type: 'array',
+                items: clusterModel
+            },
+            id: {
+                type: 'string'
+            },
+            name: {
+                type: 'string'
+            }
+        },
+        required: [
+            'clusters'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        const result = await provider.deployGraph({
+            clusters: ctx.arguments.clusters,
+            id: ctx.arguments.id,
+            name: ctx.arguments.name
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Clusters deployed to graph "${result.id}"`
+                }
+            ],
+            structuredContent: {
+                id: result.id,
+                record: result.record,
+                aliases: result.aliases
+            }
+        };
+    });
+    return {
+        create_cluster,
+        deploy_clusters
+    };
+}

package/lib/tools/connection.d.ts

@@ -1,4 +1,4 @@
-import type { SigningIdentity } from '@enkaku/token';
+import type { SigningIdentity } from '@kokuin/token';
 import { createTool } from '@mokei/context-server';
 import type { ClientContainer } from '../container.js';
 type ToolDefinition = ReturnType<typeof createTool>;

package/lib/tools/connection.js

@@ -1 +1,103 @@
-import{createTool as t}from"@mokei/context-server";import{createConnection as e,parseDatabase as n}from"../client.js";export function createConnectionTools(r,o){let c=t("Connect to a Kubun database. Accepts a SQLite file path, postgres:// URL, http(s):// URL, or :memory: for in-memory.",{type:"object",properties:{database:{type:"string",description:"SQLite file path, postgres:// URL, http(s):// URL, or :memory:"}},required:["database"],additionalProperties:!1},async t=>{null!=r.current&&await r.current.dispose();try{let c=n(t.arguments.database),a=await e({...c,identity:o});return r.current=a,{content:[{type:"text",text:`Connected to ${a.type} database: ${a.address}`}],structuredContent:{type:a.type,address:a.address}}}catch(t){return r.current=null,{isError:!0,content:[{type:"text",text:`Failed to connect: ${t instanceof Error?t.message:String(t)}`}]}}});return{connect:c,disconnect:t("Disconnect from the current Kubun database",{type:"object"},async()=>(null!=r.current&&(await r.current.dispose(),r.current=null),{content:[{type:"text",text:"Disconnected"}]})),connection_info:t("Get information about the current database connection",{type:"object"},async()=>null==r.current?{content:[{type:"text",text:"Not connected"}],structuredContent:{connected:!1}}:{content:[{type:"text",text:`Connected to ${r.current.type} database: ${r.current.address}`}],structuredContent:{connected:!0,type:r.current.type,address:r.current.address}})}}
+import { createTool } from '@mokei/context-server';
+import { createConnection, parseDatabase } from '../client.js';
+export function createConnectionTools(container, identity) {
+    const connect = createTool('Connect to a Kubun database. Accepts a SQLite file path, postgres:// URL, http(s):// URL, or :memory: for in-memory.', {
+        type: 'object',
+        properties: {
+            database: {
+                type: 'string',
+                description: 'SQLite file path, postgres:// URL, http(s):// URL, or :memory:'
+            }
+        },
+        required: [
+            'database'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        if (container.current != null) {
+            await container.current.dispose();
+        }
+        try {
+            const config = parseDatabase(ctx.arguments.database);
+            const connection = await createConnection({
+                ...config,
+                identity
+            });
+            container.current = connection;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Connected to ${connection.type} database: ${connection.address}`
+                    }
+                ],
+                structuredContent: {
+                    type: connection.type,
+                    address: connection.address
+                }
+            };
+        } catch (error) {
+            container.current = null;
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+    const disconnect = createTool('Disconnect from the current Kubun database', {
+        type: 'object'
+    }, async ()=>{
+        if (container.current != null) {
+            await container.current.dispose();
+            container.current = null;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Disconnected'
+                }
+            ]
+        };
+    });
+    const connection_info = createTool('Get information about the current database connection', {
+        type: 'object'
+    }, async ()=>{
+        if (container.current == null) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Not connected'
+                    }
+                ],
+                structuredContent: {
+                    connected: false
+                }
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Connected to ${container.current.type} database: ${container.current.address}`
+                }
+            ],
+            structuredContent: {
+                connected: true,
+                type: container.current.type,
+                address: container.current.address
+            }
+        };
+    });
+    return {
+        connect,
+        disconnect,
+        connection_info
+    };
+}

package/lib/tools/graph.js

@@ -1 +1,284 @@
-import{createSchema as e}from"@kubun/graphql";import{createTool as t}from"@mokei/context-server";import{printSchema as r}from"graphql";import{getProvider as n,notConnectedError as i}from"../container.js";export function createGraphTools(a){let o=t("List all available graphs",{type:"object"},async()=>{let e=n(a);if(null==e)return i();let t=await e.listGraphs(),r=t.graphs.map(e=>`${e.name} (${e.id})`).join(", ");return{content:[{type:"text",text:""===r?"No graphs available":`Available graphs: ${r}`}],structuredContent:{graphs:t.graphs}}}),s=t("Get information about a specific graph",{type:"object",properties:{id:{type:"string"}},required:["id"],additionalProperties:!1},async e=>{let t=n(a);if(null==t)return i();try{var r;let n,i=(n=(r=await t.loadGraph({id:e.arguments.id})).aliases??{},Object.entries(r.record).reduce((e,[t,r])=>(e[n[t]??r.name]={id:t,behavior:r.behavior,interfaces:r.interfaces,fields:Object.keys(r.schema.properties)},e),{}));return{content:[{type:"text",text:JSON.stringify(i)}],structuredContent:i}}catch(e){return{isError:!0,content:[{type:"text",text:`Failed to get GraphQL schema: ${e instanceof Error?e.message:String(e)}`}]}}}),u=t("Get the GraphQL schema for the given graph ID. Supports selective generation to reduce schema size for LLM context.",{type:"object",properties:{id:{type:"string",description:"The graph ID"},onlyModels:{type:"array",items:{type:"string"},description:"Optional array of model IDs or aliases to include in schema. If not provided, all models are included."},includeInterfaceDependencies:{type:"boolean",description:"Whether to include interface dependencies (default: true)"},includeRelationDependencies:{type:"boolean",description:"Whether to include relation dependencies (default: true)"},includeMutations:{type:"boolean",description:"Whether to include mutations in the schema (default: true)"},includeSubscriptions:{type:"boolean",description:"Whether to include subscriptions in the schema (default: true)"}},required:["id"],additionalProperties:!1},async t=>{let o=n(a);if(null==o)return i();try{let n=await o.loadGraph({id:t.arguments.id}),i=e({record:n.record,aliases:n.aliases,onlyModels:t.arguments.onlyModels,includeInterfaceDependencies:t.arguments.includeInterfaceDependencies,includeRelationDependencies:t.arguments.includeRelationDependencies,includeMutations:t.arguments.includeMutations,includeSubscriptions:t.arguments.includeSubscriptions});return{content:[{type:"text",text:r(i)}]}}catch(e){return{isError:!0,content:[{type:"text",text:`Failed to get GraphQL schema: ${e instanceof Error?e.message:String(e)}`}]}}});return{graph_list:o,graph_info:s,graph_schema:u,graph_query:t("Execute a GraphQL query on the given graph ID",{type:"object",properties:{id:{type:"string"},query:{type:"string"},variables:{type:"object"}},required:["id","query"],additionalProperties:!1},async e=>{let t=n(a);if(null==t)return i();try{let r=await t.queryGraph({id:e.arguments.id,text:e.arguments.query,variables:e.arguments.variables??{}});if(null!=r.errors&&r.errors.length>0)return{isError:!0,content:[{type:"text",text:r.errors.map(e=>e.toString()).join(", ")}],structuredContent:{errors:r.errors}};return{content:[{type:"text",text:JSON.stringify(r.data)}],structuredContent:{data:r.data}}}catch(e){return{isError:!0,content:[{type:"text",text:`Failed to execute GraphQL query: ${e instanceof Error?e.message:String(e)}`}]}}}),graph_mutate:t("Execute a GraphQL mutation on the given graph ID",{type:"object",properties:{id:{type:"string"},query:{type:"string"},variables:{type:"object"}},required:["id","query"],additionalProperties:!1},async e=>{let t=n(a);if(null==t)return i();try{let r=await t.mutateGraph({id:e.arguments.id,text:e.arguments.query,variables:e.arguments.variables??{}});if(null!=r.errors&&r.errors.length>0)return{isError:!0,content:[{type:"text",text:r.errors.map(e=>e.toString()).join(", ")}],structuredContent:{errors:r.errors}};return{content:[{type:"text",text:JSON.stringify(r.data)}],structuredContent:{data:r.data}}}catch(e){return{isError:!0,content:[{type:"text",text:`Failed to execute GraphQL mutation: ${e instanceof Error?e.message:String(e)}`}]}}})}}
+import { createSchema } from '@kubun/graphql';
+import { createTool } from '@mokei/context-server';
+import { printSchema } from 'graphql';
+import { getProvider, notConnectedError } from '../container.js';
+function getModelsInfo(result) {
+    const aliases = result.aliases ?? {};
+    return Object.entries(result.record).reduce((acc, [id, model])=>{
+        const alias = aliases[id] ?? model.name;
+        acc[alias] = {
+            id,
+            behavior: model.behavior,
+            interfaces: model.interfaces,
+            fields: Object.keys(model.schema.properties)
+        };
+        return acc;
+    }, {});
+}
+export function createGraphTools(container) {
+    const graph_list = createTool('List all available graphs', {
+        type: 'object'
+    }, async ()=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        const result = await provider.listGraphs();
+        const graphs = result.graphs.map((graph)=>`${graph.name} (${graph.id})`).join(', ');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: graphs === '' ? 'No graphs available' : `Available graphs: ${graphs}`
+                }
+            ],
+            structuredContent: {
+                graphs: result.graphs
+            }
+        };
+    });
+    const graph_info = createTool('Get information about a specific graph', {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string'
+            }
+        },
+        required: [
+            'id'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        try {
+            const result = await provider.loadGraph({
+                id: ctx.arguments.id
+            });
+            const info = getModelsInfo(result);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(info)
+                    }
+                ],
+                structuredContent: info
+            };
+        } catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get GraphQL schema: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+    const graph_schema = createTool('Get the GraphQL schema for the given graph ID. Supports selective generation to reduce schema size for LLM context.', {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string',
+                description: 'The graph ID'
+            },
+            onlyModels: {
+                type: 'array',
+                items: {
+                    type: 'string'
+                },
+                description: 'Optional array of model IDs or aliases to include in schema. If not provided, all models are included.'
+            },
+            includeInterfaceDependencies: {
+                type: 'boolean',
+                description: 'Whether to include interface dependencies (default: true)'
+            },
+            includeRelationDependencies: {
+                type: 'boolean',
+                description: 'Whether to include relation dependencies (default: true)'
+            },
+            includeMutations: {
+                type: 'boolean',
+                description: 'Whether to include mutations in the schema (default: true)'
+            },
+            includeSubscriptions: {
+                type: 'boolean',
+                description: 'Whether to include subscriptions in the schema (default: true)'
+            }
+        },
+        required: [
+            'id'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        try {
+            const result = await provider.loadGraph({
+                id: ctx.arguments.id
+            });
+            const schema = createSchema({
+                record: result.record,
+                aliases: result.aliases,
+                onlyModels: ctx.arguments.onlyModels,
+                includeInterfaceDependencies: ctx.arguments.includeInterfaceDependencies,
+                includeRelationDependencies: ctx.arguments.includeRelationDependencies,
+                includeMutations: ctx.arguments.includeMutations,
+                includeSubscriptions: ctx.arguments.includeSubscriptions
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: printSchema(schema)
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get GraphQL schema: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+    const graph_query = createTool('Execute a GraphQL query on the given graph ID', {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string'
+            },
+            query: {
+                type: 'string'
+            },
+            variables: {
+                type: 'object'
+            }
+        },
+        required: [
+            'id',
+            'query'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        try {
+            const result = await provider.queryGraph({
+                id: ctx.arguments.id,
+                text: ctx.arguments.query,
+                variables: ctx.arguments.variables ?? {}
+            });
+            if (result.errors != null && result.errors.length > 0) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: result.errors.map((e)=>e.toString()).join(', ')
+                        }
+                    ],
+                    structuredContent: {
+                        errors: result.errors
+                    }
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result.data)
+                    }
+                ],
+                structuredContent: {
+                    data: result.data
+                }
+            };
+        } catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to execute GraphQL query: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+    const graph_mutate = createTool('Execute a GraphQL mutation on the given graph ID', {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string'
+            },
+            query: {
+                type: 'string'
+            },
+            variables: {
+                type: 'object'
+            }
+        },
+        required: [
+            'id',
+            'query'
+        ],
+        additionalProperties: false
+    }, async (ctx)=>{
+        const provider = getProvider(container);
+        if (provider == null) return notConnectedError();
+        try {
+            const result = await provider.mutateGraph({
+                id: ctx.arguments.id,
+                text: ctx.arguments.query,
+                variables: ctx.arguments.variables ?? {}
+            });
+            if (result.errors != null && result.errors.length > 0) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: result.errors.map((e)=>e.toString()).join(', ')
+                        }
+                    ],
+                    structuredContent: {
+                        errors: result.errors
+                    }
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result.data)
+                    }
+                ],
+                structuredContent: {
+                    data: result.data
+                }
+            };
+        } catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to execute GraphQL mutation: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+    return {
+        graph_list,
+        graph_info,
+        graph_schema,
+        graph_query,
+        graph_mutate
+    };
+}

package/lib/tools/index.js

@@ -1 +1,3 @@
-export{createClusterTools}from"./cluster.js";export{createConnectionTools}from"./connection.js";export{createGraphTools}from"./graph.js";
+export { createClusterTools } from './cluster.js';
+export { createConnectionTools } from './connection.js';
+export { createGraphTools } from './graph.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/mcp",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -18,25 +18,25 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/token": "^0.16.0",
-    "@mokei/context-server": "^0.7.0",
-    "graphql": "^16.13.2",
-    "@kubun/db-node-sqlite": "^0.10.0",
-    "@kubun/db-postgres": "^0.10.0",
-    "@kubun/db": "^0.10.0",
-    "@kubun/engine": "^0.10.0",
-    "@kubun/graphql": "^0.10.0",
-    "@kubun/protocol": "^0.10.0",
-    "@kubun/http-client": "^0.10.0"
+    "@kokuin/token": "^0.1.1",
+    "@mokei/context-server": "^0.8.0",
+    "graphql": "^16.14.2",
+    "@kubun/db": "^0.11.0",
+    "@kubun/db-postgres": "^0.11.0",
+    "@kubun/db-node-sqlite": "^0.11.0",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/http-client": "^0.11.0",
+    "@kubun/protocol": "^0.11.0",
+    "@kubun/graphql": "^0.11.0"
   },
   "devDependencies": {
-    "@enkaku/transport": "^0.16.0",
-    "@mokei/context-client": "^0.7.0",
-    "@mokei/context-protocol": "^0.7.0"
+    "@enkaku/transport": "^0.18.1",
+    "@mokei/context-client": "^0.8.0",
+    "@mokei/context-protocol": "^0.8.0"
   },
   "scripts": {
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "test:types": "tsc --noEmit -p tsconfig.test.json",