@ldraney/github-mcp 0.1.0 → 0.2.0-beta.0

package/dist/tools/generator.d.ts

@@ -1,19 +1,39 @@
-import { Octokit } from '@octokit/rest';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { Octokit } from '@octokit/rest';
+import type { MCPToolDefinition, ToolResult } from './types.js';
 /**
- * Register tools with optional category filtering
+ * Tool generator that manages tool loading and execution
  */
-export declare function registerTools(octokit: Octokit, enabledCategories?: string[]): void;
+export declare class ToolGenerator {
+    private handlers;
+    private definitions;
+    private loadedCategories;
+    /**
+     * Load specified categories (or defaults if none specified)
+     * @param categoryNames - Array of category names to load
+     */
+    loadCategories(categoryNames?: string[]): void;
+    /**
+     * Get all tool definitions for MCP ListTools response
+     */
+    getTools(): MCPToolDefinition[];
+    /**
+     * Execute a tool by name
+     * @param octokit - Authenticated Octokit instance
+     * @param name - Tool name
+     * @param args - Tool arguments
+     */
+    executeTool(octokit: Octokit, name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * Get list of available category names
+     */
+    static getAvailableCategories(): string[];
+    /**
+     * Get count of loaded tools
+     */
+    getToolCount(): number;
+}
 /**
- * Get all registered tool definitions
+ * Create and initialize a tool generator
+ * @param categories - Optional array of category names to load
  */
-export declare function getToolDefinitions(): Tool[];
-/**
- * Handle a tool call
- */
-export declare function handleToolCall(name: string, args: Record<string, unknown>): Promise<unknown>;
-/**
- * Get list of available categories
- */
-export declare function getAvailableCategories(): string[];
-//# sourceMappingURL=generator.d.ts.map
+export declare function createToolGenerator(categories?: string[]): ToolGenerator;

package/dist/tools/generator.js

@@ -1,69 +1,125 @@
-import { reposTools, handleReposTool } from './categories/repos.js';
-import { issuesTools, handleIssuesTool } from './categories/issues.js';
-import { pullsTools, handlePullsTool } from './categories/pulls.js';
-import { usersTools, handleUsersTool } from './categories/users.js';
-import { actionsTools, handleActionsTool } from './categories/actions.js';
-import { gistsTools, handleGistsTool } from './categories/gists.js';
-import { orgsTools, handleOrgsTool } from './categories/orgs.js';
-import { searchTools, handleSearchTool } from './categories/search.js';
-// Store octokit instance for tool handlers
-let octokitInstance = null;
-// All available tool categories
-const CATEGORIES = {
-    repos: { tools: reposTools, handler: handleReposTool },
-    issues: { tools: issuesTools, handler: handleIssuesTool },
-    pulls: { tools: pullsTools, handler: handlePullsTool },
-    users: { tools: usersTools, handler: handleUsersTool },
-    actions: { tools: actionsTools, handler: handleActionsTool },
-    gists: { tools: gistsTools, handler: handleGistsTool },
-    orgs: { tools: orgsTools, handler: handleOrgsTool },
-    search: { tools: searchTools, handler: handleSearchTool },
-};
-// Active tools after filtering by enabled categories
-let activeTools = [];
-let activeHandlers = new Map();
+import { errorResult } from './types.js';
+import { reposCategory, issuesCategory, pullsCategory, usersCategory, actionsCategory, searchCategory, orgsCategory, gistsCategory, checksCategory, projectsCategory, teamsCategory, activityCategory, gitCategory, reactionsCategory, packagesCategory, dependabotCategory, secretScanningCategory, codeScanningCategory, codeSecurityCategory, securityAdvisoriesCategory, appsCategory, billingCategory, codespacesCategory, copilotCategory, migrationsCategory, interactionsCategory, rateLimitCategory, markdownCategory, metaCategory, emojisCategory, gitignoreCategory, licensesCategory, codesOfConductCategory, } from './categories/index.js';
 /**
- * Register tools with optional category filtering
+ * All available tool categories
  */
-export function registerTools(octokit, enabledCategories) {
-    octokitInstance = octokit;
-    activeTools = [];
-    activeHandlers.clear();
-    const categoriesToLoad = enabledCategories
-        ? enabledCategories.filter((c) => c in CATEGORIES)
-        : Object.keys(CATEGORIES);
-    for (const category of categoriesToLoad) {
-        const { tools, handler } = CATEGORIES[category];
-        for (const tool of tools) {
-            activeTools.push(tool);
-            activeHandlers.set(tool.name, handler);
-        }
-    }
-    console.error(`Registered ${activeTools.length} tools from ${categoriesToLoad.length} categories`);
-}
+const ALL_CATEGORIES = {
+    repos: reposCategory,
+    issues: issuesCategory,
+    pulls: pullsCategory,
+    users: usersCategory,
+    actions: actionsCategory,
+    search: searchCategory,
+    orgs: orgsCategory,
+    gists: gistsCategory,
+    checks: checksCategory,
+    projects: projectsCategory,
+    teams: teamsCategory,
+    activity: activityCategory,
+    git: gitCategory,
+    reactions: reactionsCategory,
+    packages: packagesCategory,
+    dependabot: dependabotCategory,
+    secretScanning: secretScanningCategory,
+    codeScanning: codeScanningCategory,
+    codeSecurity: codeSecurityCategory,
+    securityAdvisories: securityAdvisoriesCategory,
+    apps: appsCategory,
+    billing: billingCategory,
+    codespaces: codespacesCategory,
+    copilot: copilotCategory,
+    migrations: migrationsCategory,
+    interactions: interactionsCategory,
+    rateLimit: rateLimitCategory,
+    markdown: markdownCategory,
+    meta: metaCategory,
+    emojis: emojisCategory,
+    gitignore: gitignoreCategory,
+    licenses: licensesCategory,
+    codesOfConduct: codesOfConductCategory,
+};
 /**
- * Get all registered tool definitions
+ * Default categories to load if none specified
  */
-export function getToolDefinitions() {
-    return activeTools;
-}
+const DEFAULT_CATEGORIES = [
+    'repos', 'issues', 'pulls', 'users', 'actions', 'search', 'orgs',
+    'gists', 'checks', 'projects', 'teams', 'activity', 'git',
+    'reactions', 'packages', 'dependabot', 'secretScanning', 'codeScanning',
+    'codeSecurity', 'securityAdvisories', 'apps', 'billing', 'codespaces',
+    'copilot', 'migrations', 'interactions', 'rateLimit', 'markdown',
+    'meta', 'emojis', 'gitignore', 'licenses', 'codesOfConduct',
+];
 /**
- * Handle a tool call
+ * Tool generator that manages tool loading and execution
  */
-export async function handleToolCall(name, args) {
-    if (!octokitInstance) {
-        throw new Error('Tools not initialized. Call registerTools first.');
+export class ToolGenerator {
+    handlers = new Map();
+    definitions = [];
+    loadedCategories = [];
+    /**
+     * Load specified categories (or defaults if none specified)
+     * @param categoryNames - Array of category names to load
+     */
+    loadCategories(categoryNames) {
+        const names = categoryNames ?? DEFAULT_CATEGORIES;
+        for (const name of names) {
+            const category = ALL_CATEGORIES[name];
+            if (!category) {
+                console.error(`Warning: Unknown category "${name}", skipping`);
+                continue;
+            }
+            for (const tool of category.tools) {
+                this.handlers.set(tool.definition.name, tool.handler);
+                this.definitions.push(tool.definition);
+            }
+            this.loadedCategories.push(name);
+        }
+        console.error(`Loaded ${this.definitions.length} tools from categories: ${this.loadedCategories.join(', ')}`);
+    }
+    /**
+     * Get all tool definitions for MCP ListTools response
+     */
+    getTools() {
+        return this.definitions;
+    }
+    /**
+     * Execute a tool by name
+     * @param octokit - Authenticated Octokit instance
+     * @param name - Tool name
+     * @param args - Tool arguments
+     */
+    async executeTool(octokit, name, args) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            return errorResult(`Unknown tool: ${name}`);
+        }
+        try {
+            return await handler(octokit, args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(message);
+        }
+    }
+    /**
+     * Get list of available category names
+     */
+    static getAvailableCategories() {
+        return Object.keys(ALL_CATEGORIES);
     }
-    const handler = activeHandlers.get(name);
-    if (!handler) {
-        throw new Error(`Unknown tool: ${name}`);
+    /**
+     * Get count of loaded tools
+     */
+    getToolCount() {
+        return this.definitions.length;
     }
-    return handler(octokitInstance, args);
 }
 /**
- * Get list of available categories
+ * Create and initialize a tool generator
+ * @param categories - Optional array of category names to load
  */
-export function getAvailableCategories() {
-    return Object.keys(CATEGORIES);
+export function createToolGenerator(categories) {
+    const generator = new ToolGenerator();
+    generator.loadCategories(categories);
+    return generator;
 }
-//# sourceMappingURL=generator.js.map

package/dist/tools/types.d.ts

@@ -0,0 +1,63 @@
+import type { Octokit } from '@octokit/rest';
+/**
+ * Standardized response format for tool execution
+ * Compatible with MCP SDK's CallToolResult
+ */
+export interface ToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+/**
+ * Function signature for tool handlers
+ */
+export type ToolHandler = (octokit: Octokit, args: Record<string, unknown>) => Promise<ToolResult>;
+/**
+ * JSON Schema for tool input validation
+ */
+export interface ToolInputSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        items?: {
+            type: string;
+        };
+    }>;
+    required?: string[];
+}
+/**
+ * MCP tool definition (what gets sent to the client)
+ */
+export interface MCPToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+}
+/**
+ * Tool definition bundled with its handler
+ */
+export interface GitHubToolDefinition {
+    definition: MCPToolDefinition;
+    handler: ToolHandler;
+}
+/**
+ * A category of related tools
+ */
+export interface ToolCategory {
+    name: string;
+    description: string;
+    tools: GitHubToolDefinition[];
+}
+/**
+ * Helper to create a successful tool result
+ */
+export declare function successResult(data: unknown): ToolResult;
+/**
+ * Helper to create an error tool result
+ */
+export declare function errorResult(message: string): ToolResult;

package/dist/tools/types.js

@@ -0,0 +1,17 @@
+/**
+ * Helper to create a successful tool result
+ */
+export function successResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+/**
+ * Helper to create an error tool result
+ */
+export function errorResult(message) {
+    return {
+        content: [{ type: 'text', text: `Error: ${message}` }],
+        isError: true,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldraney/github-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0-beta.0",
   "description": "GitHub MCP server with OAuth and 800+ API endpoints",
   "type": "module",
   "main": "dist/index.js",