@kubun/mcp 0.10.0 → 0.12.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,47 @@
-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',
+        // Serve both revisions: hosts pinned to 2025-11-25 stay supported while 2026-07-28 clients
+        // get the stateless path. Nothing here uses server-initiated requests (elicit, sampling,
+        // roots), so no capability is lost by a client picking the newer revision.
+        protocolVersions: [
+            '2026-07-28',
+            '2025-11-25'
+        ],
+        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,92 @@
-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';
+const createClusterInput = {
+    type: 'object',
+    properties: {
+        models: {
+            type: 'array',
+            items: {
+                type: 'object'
+            }
+        }
+    },
+    required: [
+        'models'
+    ],
+    additionalProperties: false
+};
+const deployClustersInput = {
+    type: 'object',
+    properties: {
+        clusters: {
+            type: 'array',
+            items: clusterModel
+        },
+        id: {
+            type: 'string'
+        },
+        name: {
+            type: 'string'
+        }
+    },
+    required: [
+        'clusters'
+    ],
+    additionalProperties: false
+};
+export function createClusterTools(container) {
+    // The explicit `undefined` output schema keeps the handler's return type open:
+    // a tool declares no output schema, so a handler may return an error result
+    // carrying no `structuredContent` alongside a successful structured one.
+    const createCluster = createTool({
+        description: 'Create a new cluster from model definitions',
+        inputSchema: createClusterInput,
+        handler: async (ctx)=>{
+            const builder = new ClusterBuilder();
+            builder.addAll(ctx.input.models);
+            const cluster = builder.build();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Cluster created'
+                    }
+                ],
+                structuredContent: {
+                    cluster
+                }
+            };
+        }
+    });
+    const deployClusters = createTool({
+        description: 'Deploy clusters to the Kubun backend',
+        inputSchema: deployClustersInput,
+        handler: async (ctx)=>{
+            const provider = getProvider(container);
+            if (provider == null) return notConnectedError();
+            const result = await provider.deployGraph({
+                clusters: ctx.input.clusters,
+                id: ctx.input.id,
+                name: ctx.input.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: createCluster,
+        deploy_clusters: deployClusters
+    };
+}

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,118 @@
-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';
+const connectInput = {
+    type: 'object',
+    properties: {
+        database: {
+            type: 'string',
+            description: 'SQLite file path, postgres:// URL, http(s):// URL, or :memory:'
+        }
+    },
+    required: [
+        'database'
+    ],
+    additionalProperties: false
+};
+const emptyInput = {
+    type: 'object'
+};
+export function createConnectionTools(container, identity) {
+    // The explicit `undefined` output schema keeps the handler's return type open:
+    // a tool declares no output schema, so a handler may return an error result
+    // carrying no `structuredContent` alongside a successful structured one.
+    const connect = createTool({
+        description: 'Connect to a Kubun database. Accepts a SQLite file path, postgres:// URL, http(s):// URL, or :memory: for in-memory.',
+        inputSchema: connectInput,
+        handler: async (ctx)=>{
+            if (container.current != null) {
+                await container.current.dispose();
+            }
+            try {
+                const config = parseDatabase(ctx.input.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({
+        description: 'Disconnect from the current Kubun database',
+        inputSchema: emptyInput,
+        handler: async ()=>{
+            if (container.current != null) {
+                await container.current.dispose();
+                container.current = null;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Disconnected'
+                    }
+                ]
+            };
+        }
+    });
+    const connectionInfo = createTool({
+        description: 'Get information about the current database connection',
+        inputSchema: emptyInput,
+        handler: 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: connectionInfo
+    };
+}

package/lib/tools/graph.js

@@ -1 +1,293 @@
-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';
+const emptyInput = {
+    type: 'object'
+};
+const graphInfoInput = {
+    type: 'object',
+    properties: {
+        id: {
+            type: 'string'
+        }
+    },
+    required: [
+        'id'
+    ],
+    additionalProperties: false
+};
+const graphSchemaInput = {
+    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
+};
+const graphOperationInput = {
+    type: 'object',
+    properties: {
+        id: {
+            type: 'string'
+        },
+        query: {
+            type: 'string'
+        },
+        variables: {
+            type: 'object'
+        }
+    },
+    required: [
+        'id',
+        'query'
+    ],
+    additionalProperties: false
+};
+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) {
+    // The explicit `undefined` output schema keeps the handler's return type open:
+    // a tool declares no output schema, so a handler may return an error result
+    // carrying no `structuredContent` alongside a successful structured one.
+    const graphList = createTool({
+        description: 'List all available graphs',
+        inputSchema: emptyInput,
+        handler: 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 graphInfo = createTool({
+        description: 'Get information about a specific graph',
+        inputSchema: graphInfoInput,
+        handler: async (ctx)=>{
+            const provider = getProvider(container);
+            if (provider == null) return notConnectedError();
+            try {
+                const result = await provider.loadGraph({
+                    id: ctx.input.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 graphSchema = createTool({
+        description: 'Get the GraphQL schema for the given graph ID. Supports selective generation to reduce schema size for LLM context.',
+        inputSchema: graphSchemaInput,
+        handler: async (ctx)=>{
+            const provider = getProvider(container);
+            if (provider == null) return notConnectedError();
+            try {
+                const result = await provider.loadGraph({
+                    id: ctx.input.id
+                });
+                const schema = createSchema({
+                    record: result.record,
+                    aliases: result.aliases,
+                    onlyModels: ctx.input.onlyModels,
+                    includeInterfaceDependencies: ctx.input.includeInterfaceDependencies,
+                    includeRelationDependencies: ctx.input.includeRelationDependencies,
+                    includeMutations: ctx.input.includeMutations,
+                    includeSubscriptions: ctx.input.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 graphQuery = createTool({
+        description: 'Execute a GraphQL query on the given graph ID',
+        inputSchema: graphOperationInput,
+        handler: async (ctx)=>{
+            const provider = getProvider(container);
+            if (provider == null) return notConnectedError();
+            try {
+                const result = await provider.queryGraph({
+                    id: ctx.input.id,
+                    text: ctx.input.query,
+                    variables: ctx.input.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 graphMutate = createTool({
+        description: 'Execute a GraphQL mutation on the given graph ID',
+        inputSchema: graphOperationInput,
+        handler: async (ctx)=>{
+            const provider = getProvider(container);
+            if (provider == null) return notConnectedError();
+            try {
+                const result = await provider.mutateGraph({
+                    id: ctx.input.id,
+                    text: ctx.input.query,
+                    variables: ctx.input.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: graphList,
+        graph_info: graphInfo,
+        graph_schema: graphSchema,
+        graph_query: graphQuery,
+        graph_mutate: graphMutate
+    };
+}

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,46 +1,46 @@
 {
   "name": "@kubun/mcp",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js",
     "./run": "./lib/run.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "bin": {
     "kubun-mcp": "./lib/run.js"
   },
   "files": [
     "lib/*"
   ],
-  "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.3.0",
+    "@mokei/context-server": "^0.11.0",
+    "graphql": "^16.14.2",
+    "@kubun/db": "^0.12.0",
+    "@kubun/graphql": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0",
+    "@kubun/db-node-sqlite": "^0.12.0",
+    "@kubun/http-client": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/engine": "^0.12.0"
   },
   "devDependencies": {
-    "@enkaku/transport": "^0.16.0",
-    "@mokei/context-client": "^0.7.0",
-    "@mokei/context-protocol": "^0.7.0"
+    "@enkaku/transport": "^0.20.0",
+    "@mokei/context-client": "^0.11.0",
+    "@mokei/context-protocol": "^0.11.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "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": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }