@supermodeltools/mcp-server 0.8.0 → 0.9.0

package/dist/tools/feature-request.js

@@ -1,84 +0,0 @@
-"use strict";
-/**
- * Tool for agents to submit feature requests as GitHub issues.
- * Creates issues on the supermodeltools/mcp repository.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = exports.tool = exports.metadata = void 0;
-const types_1 = require("../types");
-const github_1 = require("../utils/github");
-exports.metadata = {
-    resource: 'issues',
-    operation: 'write',
-    tags: ['feature-request', 'github'],
-    httpMethod: 'post',
-    httpPath: '/repos/supermodeltools/mcp/issues',
-    operationId: 'createFeatureRequest',
-};
-exports.tool = {
-    name: 'request_feature',
-    description: `Submit a feature request to the Supermodel MCP server GitHub repository (${github_1.GITHUB_REPO}).
-
-Creates a GitHub issue on behalf of the agent. The Supermodel team actively monitors and responds to all submitted issues.
-
-Use this tool whenever you believe a new feature, improvement, or enhancement would be helpful for the Supermodel MCP server or its underlying API. Examples include:
-- Suggesting a new tool, query type, or graph capability
-- Requesting improvements to an existing tool (e.g. better filtering, new parameters, improved output format)
-- Proposing changes to error messages, documentation, or developer experience
-- Identifying a missing capability you needed while working on a task
-
-This tool requires a GITHUB_TOKEN environment variable. To set it up:
-1. Create a GitHub personal access token at https://github.com/settings/tokens with the "public_repo" scope
-2. Set it in your environment: export GITHUB_TOKEN=ghp_your_token_here
-3. Restart the MCP server`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            title: {
-                type: 'string',
-                description: 'Short, descriptive title for the feature request.',
-            },
-            description: {
-                type: 'string',
-                description: 'Detailed description of the feature. Include context, use cases, and expected behavior.',
-            },
-            labels: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Optional labels to categorize the issue (e.g. ["enhancement"]).',
-            },
-        },
-        required: ['title', 'description'],
-    },
-};
-const handler = async (_client, args) => {
-    const tokenError = (0, github_1.validateGitHubToken)();
-    if (tokenError)
-        return (0, types_1.asErrorResult)(tokenError);
-    if (!args) {
-        return (0, types_1.asErrorResult)({
-            type: 'validation_error',
-            message: 'Missing required parameters: title and description.',
-            code: 'MISSING_PARAMETERS',
-            recoverable: false,
-            suggestion: 'Provide both "title" and "description" parameters.',
-        });
-    }
-    const { title, description, labels } = args;
-    const titleError = (0, github_1.validateRequiredString)(title, 'title', 'INVALID_TITLE', 'Provide a short, descriptive title as a string.');
-    if (titleError)
-        return (0, types_1.asErrorResult)(titleError);
-    const descError = (0, github_1.validateRequiredString)(description, 'description', 'INVALID_DESCRIPTION', 'Provide a detailed description as a string.');
-    if (descError)
-        return (0, types_1.asErrorResult)(descError);
-    const labelsError = (0, github_1.validateLabels)(labels);
-    if (labelsError)
-        return (0, types_1.asErrorResult)(labelsError);
-    return (0, github_1.createGitHubIssue)('request_feature', {
-        title: title,
-        body: description,
-        labels: labels,
-    }, 'Feature request created successfully.');
-};
-exports.handler = handler;
-exports.default = { metadata: exports.metadata, tool: exports.tool, handler: exports.handler };

package/dist/tools/find-call-sites.js

@@ -1,140 +0,0 @@
-"use strict";
-/**
- * Task-specific tool: Find call sites for a function
- * Lightweight, focused query without full graph overhead
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findCallSitesTool = void 0;
-exports.findCallSites = findCallSites;
-const zod_1 = require("zod");
-const cache_1 = require("../cache");
-const FindCallSitesArgsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe('Repository path'),
-    function_name: zod_1.z.string().describe('Name of function to find call sites for'),
-    include_context: zod_1.z.boolean().optional().describe('Include surrounding code context'),
-    max_results: zod_1.z.number().optional().describe('Maximum number of results to return'),
-});
-/**
- * Find all places where a function is called
- */
-async function findCallSites(args) {
-    const { path, function_name, include_context = true, max_results = 10 } = args;
-    // Get cached graph
-    const cacheKey = getCacheKey(path);
-    const graph = cache_1.graphCache.get(cacheKey);
-    if (!graph) {
-        throw new Error('Graph not cached. Run explore_codebase first to analyze the repository.');
-    }
-    // Find function node by name (case-insensitive)
-    const functionNodes = findFunctionsByName(graph, function_name);
-    if (functionNodes.length === 0) {
-        return {
-            function_name,
-            total_call_sites: 0,
-            call_sites: [],
-            summary: `Function "${function_name}" not found in codebase.`,
-        };
-    }
-    // Use first match if multiple functions with same name
-    const targetNode = functionNodes[0];
-    const targetId = targetNode.id;
-    // Get incoming call edges
-    const callAdj = graph.callAdj.get(targetId);
-    if (!callAdj || callAdj.in.length === 0) {
-        return {
-            function_name,
-            total_call_sites: 0,
-            call_sites: [],
-            summary: `Function "${function_name}" is not called by any other functions.`,
-        };
-    }
-    // Build call site results
-    const callSites = [];
-    for (const callerId of callAdj.in) {
-        const callerNode = graph.nodeById.get(callerId);
-        if (!callerNode)
-            continue;
-        // Find edge details (if available)
-        const edge = findCallEdge(graph, callerId, targetId);
-        const result = {
-            caller: {
-                name: callerNode.properties?.name || 'unknown',
-                file: callerNode.properties?.filePath || 'unknown',
-                line: callerNode.properties?.startLine || 0,
-            },
-            call_site: {
-                line: edge?.properties?.lineNumber || 0,
-                column: edge?.properties?.columnNumber,
-                context: edge?.properties?.context,
-                code_snippet: include_context ? edge?.properties?.codeSnippet : undefined,
-            },
-        };
-        callSites.push(result);
-        if (callSites.length >= max_results) {
-            break;
-        }
-    }
-    // Generate summary
-    const summary = generateSummary(function_name, callSites, callAdj.in.length);
-    return {
-        function_name,
-        total_call_sites: callAdj.in.length,
-        call_sites: callSites,
-        summary,
-    };
-}
-/**
- * Helper: Find function nodes by name
- */
-function findFunctionsByName(graph, name) {
-    const lowerName = name.toLowerCase();
-    const nodeIds = graph.nameIndex.get(lowerName) || [];
-    return nodeIds
-        .map((id) => graph.nodeById.get(id))
-        .filter((node) => node && node.labels?.[0] === 'Function');
-}
-/**
- * Helper: Find specific call edge between two functions
- */
-function findCallEdge(graph, fromId, toId) {
-    // In original cache, edges aren't indexed by ID
-    // This is a limitation we'd fix in edge-aware cache
-    // For now, search through raw relationships
-    const relationships = graph.raw?.graph?.relationships || [];
-    return relationships.find((rel) => rel.type === 'calls' && rel.startNode === fromId && rel.endNode === toId);
-}
-/**
- * Helper: Generate natural language summary
- */
-function generateSummary(functionName, callSites, total) {
-    if (callSites.length === 0) {
-        return `Function "${functionName}" is not called by any functions.`;
-    }
-    const callerNames = callSites.map(cs => cs.caller.name);
-    const uniqueFiles = new Set(callSites.map(cs => cs.caller.file));
-    let summary = `Function "${functionName}" is called by ${total} function(s) in ${uniqueFiles.size} file(s).`;
-    if (callSites.length > 0) {
-        summary += ` Primary callers: ${callerNames.slice(0, 3).join(', ')}`;
-        if (total > 3) {
-            summary += ` and ${total - 3} more`;
-        }
-        summary += '.';
-    }
-    return summary;
-}
-/**
- * Helper: Generate cache key (simplified - should match main implementation)
- */
-function getCacheKey(path) {
-    // In real implementation, this would include git hash, etc.
-    return `cache_${path}`;
-}
-/**
- * Tool metadata for MCP registration
- */
-exports.findCallSitesTool = {
-    name: 'find_call_sites',
-    description: 'Find all places where a specific function is called, with line numbers and context',
-    inputSchema: FindCallSitesArgsSchema,
-    handler: findCallSites,
-};

package/dist/tools/find-definition.js

@@ -1,160 +0,0 @@
-"use strict";
-/**
- * Task-specific tool: Find definition of a symbol
- * Fast lookup in cache indexes to locate where something is defined
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findDefinitionTool = void 0;
-exports.findDefinition = findDefinition;
-const zod_1 = require("zod");
-const cache_1 = require("../cache");
-const FindDefinitionArgsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe('Repository path'),
-    name: zod_1.z.string().describe('Name of the symbol to find'),
-    type: zod_1.z.enum(['function', 'class', 'variable', 'type', 'any']).optional().describe('Type of symbol'),
-    max_results: zod_1.z.number().optional().describe('Maximum number of results if multiple matches'),
-});
-/**
- * Find where a symbol is defined
- */
-async function findDefinition(args) {
-    const { path, name, type = 'any', max_results = 5 } = args;
-    // Get cached graph
-    const cacheKey = getCacheKey(path);
-    const graph = cache_1.graphCache.get(cacheKey);
-    if (!graph) {
-        throw new Error('Graph not cached. Run explore_codebase first to analyze the repository.');
-    }
-    // Find nodes by name (case-insensitive)
-    const lowerName = name.toLowerCase();
-    const nodeIds = graph.nameIndex.get(lowerName) || [];
-    if (nodeIds.length === 0) {
-        return {
-            query_name: name,
-            query_type: type,
-            found: false,
-            results: [],
-            summary: `No definition found for "${name}".`,
-        };
-    }
-    // Filter by type if specified
-    const nodes = nodeIds
-        .map(id => graph.nodeById.get(id))
-        .filter((node) => node !== undefined && matchesType(node, type))
-        .slice(0, max_results);
-    if (nodes.length === 0) {
-        return {
-            query_name: name,
-            query_type: type,
-            found: false,
-            results: [],
-            summary: `No ${type} definition found for "${name}".`,
-        };
-    }
-    // Build results
-    const results = nodes.map(node => {
-        const props = node.properties || {};
-        return {
-            name: props.name || name,
-            type: node.labels?.[0] || 'unknown',
-            file: props.filePath || 'unknown',
-            line: props.startLine || 0,
-            end_line: props.endLine,
-            kind: props.kind,
-            context: buildContext(node),
-        };
-    });
-    // Generate summary
-    const summary = generateSummary(name, type, results);
-    return {
-        query_name: name,
-        query_type: type,
-        found: true,
-        results,
-        summary,
-    };
-}
-/**
- * Check if node matches the requested type
- */
-function matchesType(node, requestedType) {
-    if (requestedType === 'any') {
-        return true;
-    }
-    const primaryLabel = node.labels?.[0]?.toLowerCase() || '';
-    // Map requested type to node labels
-    const typeMap = {
-        function: ['function', 'method'],
-        class: ['class', 'interface', 'struct'],
-        variable: ['variable', 'constant', 'parameter', 'field'],
-        type: ['type', 'typedef', 'enum', 'interface'],
-    };
-    const acceptedLabels = typeMap[requestedType] || [requestedType];
-    return acceptedLabels.some(label => primaryLabel.includes(label));
-}
-/**
- * Build context string for a definition
- */
-function buildContext(node) {
-    const props = node.properties || {};
-    const label = node.labels?.[0] || 'symbol';
-    const parts = [];
-    // Add scope if available
-    if (props.scope) {
-        parts.push(`in ${props.scope}`);
-    }
-    // Add signature for functions
-    if (label === 'Function' && props.signature) {
-        parts.push(`signature: ${props.signature}`);
-    }
-    // Add modifiers
-    const modifiers = [];
-    if (props.isStatic)
-        modifiers.push('static');
-    if (props.isAsync)
-        modifiers.push('async');
-    if (props.isPublic)
-        modifiers.push('public');
-    if (props.isPrivate)
-        modifiers.push('private');
-    if (modifiers.length > 0) {
-        parts.push(modifiers.join(' '));
-    }
-    return parts.join(', ') || undefined;
-}
-/**
- * Generate natural language summary
- */
-function generateSummary(name, type, results) {
-    if (results.length === 0) {
-        return `No definition found for "${name}".`;
-    }
-    if (results.length === 1) {
-        const result = results[0];
-        return `${result.type} "${name}" defined in ${result.file}:${result.line}`;
-    }
-    // Multiple results
-    const typeCount = new Map();
-    for (const result of results) {
-        typeCount.set(result.type, (typeCount.get(result.type) || 0) + 1);
-    }
-    const typeSummary = Array.from(typeCount.entries())
-        .map(([t, count]) => `${count} ${t}${count > 1 ? 's' : ''}`)
-        .join(', ');
-    return `Found ${results.length} definitions for "${name}": ${typeSummary}`;
-}
-/**
- * Helper: Generate cache key
- */
-function getCacheKey(path) {
-    return `cache_${path}`;
-}
-/**
- * Tool metadata for MCP registration
- */
-exports.findDefinitionTool = {
-    name: 'find_definition',
-    description: 'Find where a symbol (function, class, variable, type) is defined in the codebase',
-    inputSchema: FindDefinitionArgsSchema,
-    handler: findDefinition,
-};

package/dist/tools/graph-tools.js

@@ -1,277 +0,0 @@
-"use strict";
-/**
- * Individual graph type tools for targeted codebase analysis.
- * Each tool calls a specific graph API endpoint for focused results.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphTools = exports.parseGraphTool = exports.domainGraphTool = exports.dependencyGraphTool = exports.callGraphTool = void 0;
-const promises_1 = require("fs/promises");
-const buffer_1 = require("buffer");
-const types_1 = require("../types");
-const filtering_1 = require("../filtering");
-const zip_repository_1 = require("../utils/zip-repository");
-const logger = __importStar(require("../utils/logger"));
-const api_helpers_1 = require("../utils/api-helpers");
-const GRAPH_TYPES = [
-    {
-        name: 'call',
-        toolName: 'get_call_graph',
-        description: `Generate a call graph showing function-to-function call relationships.
-
-Returns: Function nodes with "calls" relationships between them.
-
-Use this to:
-- Find all callers of a specific function
-- Find all functions called by a specific function
-- Trace execution flow through the codebase
-- Debug by following call chains
-
-Best for: Debugging, understanding "what calls what", tracing execution paths.`,
-        endpoint: '/v1/graphs/call',
-        operationId: 'generateCallGraph',
-        apiMethod: 'generateCallGraph',
-    },
-    {
-        name: 'dependency',
-        toolName: 'get_dependency_graph',
-        description: `Generate a dependency graph showing import relationships between files.
-
-Returns: File nodes with "IMPORTS" relationships between them.
-
-Use this to:
-- Map which files import which other files
-- Find circular dependencies
-- Understand module coupling
-- Plan safe refactoring of imports
-
-Best for: Refactoring, understanding module dependencies, finding import cycles.`,
-        endpoint: '/v1/graphs/dependency',
-        operationId: 'generateDependencyGraph',
-        apiMethod: 'generateDependencyGraph',
-    },
-    {
-        name: 'domain',
-        toolName: 'get_domain_graph',
-        description: `Generate a domain classification graph showing high-level architecture.
-
-Returns: Domains with descriptions, responsibilities, subdomains, and file/function/class assignments.
-
-Use this to:
-- Understand the architectural structure of a codebase
-- See how code is organized into logical domains
-- Identify domain boundaries and responsibilities
-- Get a bird's-eye view before diving into details
-
-Best for: New codebases, architecture overview, understanding system organization.`,
-        endpoint: '/v1/graphs/domain',
-        operationId: 'generateDomainGraph',
-        apiMethod: 'generateDomainGraph',
-    },
-    {
-        name: 'parse',
-        toolName: 'get_parse_graph',
-        description: `Generate a full parse graph with all code structure elements.
-
-Returns: All nodes (File, Directory, Class, Function, Type) and structural relationships (CONTAINS, DEFINES, DECLARES, IMPORTS).
-
-Use this to:
-- Get complete structural information about the codebase
-- Find all classes, functions, and types
-- Understand containment and definition relationships
-- Support detailed refactoring analysis
-
-Best for: Comprehensive analysis when you need the full code structure.`,
-        endpoint: '/v1/graphs/parse',
-        operationId: 'generateParseGraph',
-        apiMethod: 'generateParseGraph',
-    },
-];
-/**
- * Create a tool definition and handler for a specific graph type
- */
-function createGraphTool(config) {
-    const metadata = {
-        resource: 'graphs',
-        operation: 'write',
-        tags: [config.name],
-        httpMethod: 'post',
-        httpPath: config.endpoint,
-        operationId: config.operationId,
-    };
-    const tool = {
-        name: config.toolName,
-        description: config.description,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                directory: {
-                    type: 'string',
-                    description: 'Path to the repository directory to analyze.',
-                },
-                jq_filter: {
-                    type: 'string',
-                    title: 'jq Filter',
-                    description: 'Optional jq filter to extract specific data from the response.',
-                },
-            },
-            required: [],
-        },
-    };
-    const handler = async (client, args, defaultWorkdir) => {
-        if (!args) {
-            args = {};
-        }
-        const { jq_filter, directory: providedDirectory } = args;
-        if (providedDirectory !== undefined && typeof providedDirectory !== 'string') {
-            return (0, types_1.asErrorResult)({
-                type: 'validation_error',
-                message: 'Invalid "directory" parameter. Provide a valid directory path as a string.',
-                code: 'INVALID_DIRECTORY',
-                recoverable: false,
-                suggestion: 'Pass directory as a string path, e.g. directory="/workspace/my-repo".',
-            });
-        }
-        if (jq_filter !== undefined && typeof jq_filter !== 'string') {
-            return (0, types_1.asErrorResult)({
-                type: 'validation_error',
-                message: 'Invalid "jq_filter" parameter. Provide a jq filter string.',
-                code: 'INVALID_JQ_FILTER',
-                recoverable: false,
-                suggestion: 'Pass jq_filter as a string, e.g. jq_filter=".nodes".',
-            });
-        }
-        const directory = providedDirectory ?? defaultWorkdir;
-        if (!directory || typeof directory !== 'string') {
-            return (0, types_1.asErrorResult)({
-                type: 'validation_error',
-                message: 'No "directory" parameter provided and no default workdir configured.',
-                code: 'MISSING_DIRECTORY',
-                recoverable: false,
-                suggestion: 'Provide a directory path or start the MCP server with a workdir argument.',
-            });
-        }
-        const idempotencyKey = (0, api_helpers_1.generateIdempotencyKey)(directory, config.name);
-        logger.debug(`[${config.toolName}] Idempotency key:`, idempotencyKey);
-        // Create ZIP of repository
-        let zipPath;
-        let cleanup = null;
-        try {
-            const zipResult = await (0, zip_repository_1.zipRepository)(directory);
-            zipPath = zipResult.path;
-            cleanup = zipResult.cleanup;
-            logger.debug(`[${config.toolName}] ZIP created:`, zipResult.fileCount, 'files,', (0, api_helpers_1.formatBytes)(zipResult.sizeBytes));
-        }
-        catch (error) {
-            const message = typeof error?.message === 'string' ? error.message : String(error);
-            if (message.includes('does not exist')) {
-                return (0, types_1.asErrorResult)({
-                    type: 'not_found_error',
-                    message: `Directory not found: ${directory}`,
-                    code: 'DIRECTORY_NOT_FOUND',
-                    recoverable: false,
-                    suggestion: 'Verify the path exists.',
-                });
-            }
-            return (0, types_1.asErrorResult)({
-                type: 'internal_error',
-                message: `Failed to create ZIP archive: ${message}`,
-                code: 'ZIP_CREATION_FAILED',
-                recoverable: false,
-                reportable: true,
-                repo: api_helpers_1.REPORT_REPO,
-                suggestion: api_helpers_1.REPORT_SUGGESTION,
-            });
-        }
-        try {
-            const fileBuffer = await (0, promises_1.readFile)(zipPath);
-            const fileBlob = new buffer_1.Blob([fileBuffer], { type: 'application/zip' });
-            logger.debug(`[${config.toolName}] Calling API...`);
-            console.error(`[Supermodel] Generating ${config.name} graph...`);
-            // Call the appropriate API method via SupermodelClient
-            const apiMethod = client.graphs[config.apiMethod].bind(client.graphs);
-            const response = await apiMethod(fileBlob, { idempotencyKey });
-            console.error(`[Supermodel] ${config.name} graph complete.`);
-            // Apply optional jq filter
-            const result = await (0, filtering_1.maybeFilter)(jq_filter, response);
-            return (0, types_1.asTextContentResult)(result);
-        }
-        catch (error) {
-            if ((0, filtering_1.isJqError)(error)) {
-                logger.error(`[${config.toolName}] jq filter error:`, error.message);
-                return (0, types_1.asErrorResult)({
-                    type: 'validation_error',
-                    message: `Invalid jq filter syntax: ${error.message}`,
-                    code: 'INVALID_JQ_FILTER',
-                    recoverable: false,
-                    suggestion: 'Check jq filter syntax. Example: jq_filter=".nodes" or jq_filter=".graph.nodeCount"',
-                });
-            }
-            logger.error(`[${config.toolName}] API error:`, error.message);
-            return (0, types_1.asErrorResult)((0, api_helpers_1.classifyApiError)(error));
-        }
-        finally {
-            if (cleanup) {
-                try {
-                    await cleanup();
-                }
-                catch (cleanupError) {
-                    logger.warn(`[${config.toolName}] Cleanup failed:`, cleanupError);
-                }
-            }
-        }
-    };
-    return { metadata, tool, handler };
-}
-// Helper to find graph type by name (safer than array indexing)
-function getGraphType(name) {
-    const config = GRAPH_TYPES.find(t => t.name === name);
-    if (!config) {
-        throw new Error(`Unknown graph type: ${name}`);
-    }
-    return config;
-}
-// Create all graph tools
-exports.callGraphTool = createGraphTool(getGraphType('call'));
-exports.dependencyGraphTool = createGraphTool(getGraphType('dependency'));
-exports.domainGraphTool = createGraphTool(getGraphType('domain'));
-exports.parseGraphTool = createGraphTool(getGraphType('parse'));
-// Export all tools as an array for easy registration
-exports.graphTools = [
-    exports.callGraphTool,
-    exports.dependencyGraphTool,
-    exports.domainGraphTool,
-    exports.parseGraphTool,
-];