backlog-mcp-server 0.17.0 → 0.18.0

package/build/utils/toolsetUtils.js

@@ -1,16 +1,4 @@
 import { allTools } from '../tools/tools.js';
-export function getToolset(group, name) {
-    return group.toolsets.find((t) => t.name === name);
-}
-export function enableToolset(group, name) {
-    const ts = getToolset(group, name);
-    if (!ts)
-        return `Toolset ${name} not found`;
-    if (ts.enabled)
-        return `Toolset ${name} is already enabled`;
-    ts.enabled = true;
-    return `Toolset ${name} enabled`;
-}
 export const buildToolsetGroup = (backlog, helper, enabledToolsets) => {
     const toolsetGroup = allTools(backlog, helper);
     const knownNames = toolsetGroup.toolsets.map((ts) => ts.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backlog-mcp-server",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "bin": {
     "backlog-mcp-server": "./build/index.js"
@@ -38,7 +38,6 @@
     "@modelcontextprotocol/server": "^2.0.0",
     "backlog-js": "^0.19.1",
     "env-var": "^7.5.0",
-    "graphql": "^17.0.2",
     "hono": "^4.12.34",
     "js-yaml": "^5.2.3",
     "pino": "^10.3.1",

package/build/tools/dynamicTools/toolsets.d.ts

@@ -1,15 +0,0 @@
-import { z } from 'zod';
-import { DynamicToolDefinition, ToolRegistrar } from '../../types/tool.js';
-import { DynamicToolsetGroup, ToolsetGroup } from '../../types/toolsets.js';
-import { DescriptionHelper } from '../../createDescriptionHelper.js';
-export declare const dynamicTools: (toolRegistrar: ToolRegistrar, helper: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolsetGroup;
-declare const enableToolsetSchema: (t: DescriptionHelper["t"]) => {
-    toolset: z.ZodString;
-};
-export declare const enableToolsetTool: (toolRegistrar: ToolRegistrar, { t }: DescriptionHelper) => DynamicToolDefinition<ReturnType<typeof enableToolsetSchema>>;
-export declare const listAvailableToolsets: ({ t }: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolDefinition<Record<string, never>>;
-declare const getToolsetToolsSchema: (t: DescriptionHelper["t"]) => {
-    toolset: z.ZodString;
-};
-export declare const getToolsetTools: ({ t }: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolDefinition<ReturnType<typeof getToolsetToolsSchema>>;
-export {};

package/build/tools/dynamicTools/toolsets.js

@@ -1,103 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema, } from '../../types/tool.js';
-export const dynamicTools = function (toolRegistrar, helper, toolsetGroup) {
-    return {
-        toolsets: [
-            {
-                name: 'dynamic_tools',
-                description: 'Tools for managing Backlog space settings and general information.',
-                enabled: true,
-                tools: [
-                    enableToolsetTool(toolRegistrar, helper),
-                    listAvailableToolsets(helper, toolsetGroup),
-                    getToolsetTools(helper, toolsetGroup),
-                ],
-            },
-        ],
-    };
-};
-const enableToolsetSchema = buildToolSchema((t) => ({
-    toolset: z
-        .string()
-        .describe(t('TOOL_ENABLE_TOOLSET_TOOLSET', 'Enable a toolset')),
-}));
-export const enableToolsetTool = (toolRegistrar, { t }) => {
-    return {
-        name: 'enable_toolset',
-        description: t('TOOL_ENABLE_TOOLSET_DESCRIPTION', 'Enable one of the Backlog MCP server toolsets. Use get_toolset_tools and list_available_toolsets first to inspect what this will enable.'),
-        schema: z.object(enableToolsetSchema(t)),
-        handler: async ({ toolset }) => {
-            const msg = await toolRegistrar.enableToolsetAndRefresh(toolset);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: msg,
-                    },
-                ],
-            };
-        },
-    };
-};
-export const listAvailableToolsets = ({ t }, toolsetGroup) => {
-    return {
-        name: 'list_available_toolsets',
-        description: t('TOOL_LIST_AVAILABLE_TOOLSETS_DESCRIPTION', 'List all available toolsets.'),
-        schema: z.object({}),
-        handler: async () => {
-            const result = toolsetGroup.toolsets.map((ts) => ({
-                name: ts.name,
-                description: ts.description,
-                currentlyEnabled: ts.enabled,
-                canEnable: true,
-            }));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        },
-    };
-};
-const getToolsetToolsSchema = buildToolSchema((t) => ({
-    toolset: z
-        .string()
-        .describe(t('TOOL_GET_TOOLSET_TOOLS_TOOLSET', 'Toolset name to inspect')),
-}));
-export const getToolsetTools = ({ t }, toolsetGroup) => {
-    return {
-        name: 'get_toolset_tools',
-        description: t('TOOL_GET_TOOLSET_TOOLS_DESCRIPTION', 'List all tools in a specific toolset.'),
-        schema: z.object(getToolsetToolsSchema(t)),
-        handler: async ({ toolset }) => {
-            const found = toolsetGroup.toolsets.find((ts) => ts.name === toolset);
-            if (!found) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Toolset '${toolset}' not found.`,
-                        },
-                    ],
-                };
-            }
-            const tools = found.tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                toolset: found.name,
-                canEnable: true,
-            }));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(tools, null, 2),
-                    },
-                ],
-            };
-        },
-    };
-};