@gala-chain/launchpad-mcp-server 1.24.1 → 1.25.0

package/docs/examples/tool-factory-pattern.md

@@ -1,217 +0,0 @@
-# Tool Factory Pattern Examples
-
-Demonstrates how to use `tool-factory.ts` utilities to eliminate duplication. These examples show the before/after comparison for common tool patterns.
-
-**See**: `src/utils/tool-factory.ts`
-
----
-
-## Example 1: Simple Token Fetch Tool (BEFORE vs AFTER)
-
-### ❌ BEFORE: Manual duplication (22 lines)
-
-```typescript
-export const fetchPoolDetailsToolOLD: MCPTool = {
-  name: 'gala_launchpad_fetch_pool_details',
-  description: 'Get detailed pool state from GalaChain bonding curve',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      tokenName: TOKEN_NAME_SCHEMA,
-    },
-    required: ['tokenName'],
-  },
-  handler: withErrorHandling(async (sdk, args) => {
-    const result = await sdk.fetchPoolDetails(args.tokenName);
-    return formatSuccess(result);
-  }),
-};
-```
-
-### ✅ AFTER: Using factory (6 lines - 73% reduction)
-
-```typescript
-export const fetchPoolDetailsToolNEW = createSimpleTokenFetchTool({
-  name: 'gala_launchpad_fetch_pool_details',
-  description: 'Get detailed pool state from GalaChain bonding curve',
-  handler: (sdk, tokenName) => sdk.fetchPoolDetails(tokenName),
-});
-```
-
----
-
-## Example 2: Boolean Check Tool (BEFORE vs AFTER)
-
-### ❌ BEFORE: Manual duplication (25 lines)
-
-```typescript
-export const checkTokenNameToolOLD: MCPTool = {
-  name: 'gala_launchpad_check_token_name',
-  description: 'Check if token name is available',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      tokenName: {
-        type: 'string',
-        pattern: '^[a-z0-9_-]{2,20}$',
-        description: 'Token name to check',
-      },
-    },
-    required: ['tokenName'],
-  },
-  handler: withErrorHandling(async (sdk, args) => {
-    const available = await sdk.isTokenNameAvailable(args.tokenName);
-    return formatBoolean(
-      available,
-      available ? 'Token name is available' : 'Token name is already taken'
-    );
-  }),
-};
-```
-
-### ✅ AFTER: Using factory (10 lines - 60% reduction)
-
-```typescript
-export const checkTokenNameToolNEW = createBooleanCheckTool({
-  name: 'gala_launchpad_check_token_name',
-  description: 'Check if token name is available',
-  paramName: 'tokenName',
-  paramSchema: TOKEN_NAME_SCHEMA,
-  handler: (sdk, tokenName) => sdk.isTokenNameAvailable(tokenName),
-  messages: {
-    true: 'Token name is available',
-    false: 'Token name is already taken',
-  },
-});
-```
-
----
-
-## Example 3: Resolution Tool (BEFORE vs AFTER)
-
-### ❌ BEFORE: Manual duplication (22 lines)
-
-```typescript
-export const resolveVaultAddressToolOLD: MCPTool = {
-  name: 'gala_launchpad_resolve_vault_address',
-  description: 'Get GalaChain vault address for a token (useful for debugging)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      tokenName: TOKEN_NAME_SCHEMA,
-    },
-    required: ['tokenName'],
-  },
-  handler: withErrorHandling(async (sdk, args) => {
-    const vaultAddress = await sdk.resolveVaultAddress(args.tokenName);
-    return formatSuccess({ tokenName: args.tokenName, vaultAddress });
-  }),
-};
-```
-
-### ✅ AFTER: Using factory (6 lines - 73% reduction)
-
-```typescript
-export const resolveVaultAddressToolNEW = createResolutionTool({
-  name: 'gala_launchpad_resolve_vault_address',
-  description: 'Get GalaChain vault address for a token (useful for debugging)',
-  resolver: (sdk, tokenName) => sdk.resolveVaultAddress(tokenName),
-  resultKey: 'vaultAddress',
-});
-```
-
----
-
-## Example 4: Complex Fetch Tool with Custom Schema (BEFORE vs AFTER)
-
-### ❌ BEFORE: Manual duplication (28 lines)
-
-```typescript
-export const fetchPoolsToolOLD: MCPTool = {
-  name: 'gala_launchpad_fetch_pools',
-  description: 'Fetch token pools from Gala Launchpad with filtering and pagination',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      type: {
-        type: 'string',
-        enum: Object.values(POOL_TYPES),
-        description: 'Type of pools to fetch (default: recent)',
-      },
-      page: PAGE_SCHEMA,
-      limit: createLimitSchema('pool', 20),
-    },
-  },
-  handler: withErrorHandling(async (sdk, args) => {
-    const result = await sdk.fetchPools({
-      type: args.type || 'recent',
-      page: args.page || 1,
-      limit: args.limit || 20,
-    });
-    return formatSuccess(result);
-  }),
-};
-```
-
-### ✅ AFTER: Using factory (21 lines - 25% reduction)
-
-```typescript
-export const fetchPoolsToolNEW = createFetchTool({
-  name: 'gala_launchpad_fetch_pools',
-  description: 'Fetch token pools from Gala Launchpad with filtering and pagination',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      type: {
-        type: 'string',
-        enum: Object.values(POOL_TYPES),
-        description: 'Type of pools to fetch (default: recent)',
-      },
-      page: PAGE_SCHEMA,
-      limit: createLimitSchema('pool', 20),
-    },
-  },
-  handler: (sdk, args) =>
-    sdk.fetchPools({
-      type: args.type || 'recent',
-      page: args.page || 1,
-      limit: args.limit || 20,
-    }),
-});
-```
-
----
-
-## Summary Statistics
-
-### IMPACT ANALYSIS:
-
-**Tools that can use createSimpleTokenFetchTool (73% reduction):**
-- fetchPoolDetailsTool
-- fetchTokenDistributionTool
-- fetchTokenBadgesTool
-- Total: ~15 tools across the codebase
-
-**Tools that can use createBooleanCheckTool (60% reduction):**
-- checkTokenNameTool
-- checkTokenSymbolTool
-- isTokenGraduatedTool
-- Total: ~3 tools
-
-**Tools that can use createResolutionTool (73% reduction):**
-- resolveVaultAddressTool
-- resolveTokenClassKeyTool
-- Total: ~2 tools
-
-**Tools that can use createFetchTool (25% reduction):**
-- fetchPoolsTool
-- fetchTradesTool
-- fetchTokensHeldTool
-- fetchTokensCreatedTool
-- Total: ~10 tools
-
-### OVERALL IMPACT:
-- ~30 out of 47 tools can use factory pattern
-- Average reduction: 50% fewer lines per tool
-- Total saved: ~500-700 lines of duplicated code
-- Improved maintainability: Changes to error handling, formatting, etc. only need to be made once

package/jest.config.js

@@ -1,94 +0,0 @@
-/**
- * Jest Configuration for Gala Launchpad MCP Server
- *
- * TypeScript-first testing configuration with comprehensive coverage thresholds
- */
-
-module.exports = {
-  // Use ts-jest for TypeScript support
-  preset: 'ts-jest',
-
-  // Node.js environment (MCP server is server-side)
-  testEnvironment: 'node',
-
-  // Test file location patterns
-  roots: ['<rootDir>/src'],
-  testMatch: [
-    '**/__tests__/**/*.test.ts',
-    '**/__tests__/**/*.spec.ts',
-  ],
-
-  // Coverage collection
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/__tests__/**',
-    '!src/**/*.d.ts',
-    '!src/index.ts', // Entry point - covered by integration tests
-  ],
-
-  // Coverage thresholds disabled for mixed codebase
-  // Note: New code has 92%+ coverage (validation.ts, prompt refactoring)
-  // Existing tools (47 MCP tools) are tested via integration, not unit tests
-  // This is intentional - unit testing tools would require mocking entire SDK
-  //
-  // Coverage Summary:
-  // - validation.ts: 92% branches, 100% functions, 91% lines (EXCELLENT)
-  // - Prompt tests: 119/119 passing with comprehensive edge cases
-  // - Overall: 30% due to untested tools (tested via real SDK integration)
-  //
-  // Uncomment below to enforce thresholds when tool coverage is added:
-  // coverageThreshold: {
-  //   global: { branches: 80, functions: 80, lines: 80, statements: 80 },
-  // },
-
-  // Coverage reporters
-  coverageReporters: ['text', 'text-summary', 'html', 'lcov'],
-
-  // Module path aliases and extension mapping
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/src/$1',
-    '^(\\.{1,2}/.*)\\.js$': '$1', // Map .js imports to .ts files
-  },
-
-  // Transform files with ts-jest
-  transform: {
-    '^.+\\.ts$': ['ts-jest', {
-      tsconfig: {
-        // Use ES modules
-        module: 'commonjs',
-        // Ensure strict type checking in tests
-        strict: true,
-        esModuleInterop: true,
-        skipLibCheck: true,
-      },
-    }],
-  },
-
-  // File extensions to consider
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
-
-  // Ignore patterns
-  testPathIgnorePatterns: [
-    '/node_modules/',
-    '/dist/',
-    '/.history/',
-    '/integration/', // Integration tests have their own config
-  ],
-
-  // Transform ESM packages in node_modules
-  transformIgnorePatterns: [
-    'node_modules/(?!(uuid|@gala-chain)/)',
-  ],
-
-  // Setup files (if needed for global test setup)
-  // setupFilesAfterEnv: ['<rootDir>/src/__tests__/setup.ts'],
-
-  // Clear mocks between tests
-  clearMocks: true,
-
-  // Verbose output
-  verbose: true,
-
-  // Maximum worker threads (optimize for CI/CD)
-  maxWorkers: '50%',
-};

package/src/__tests__/integration/fetchTokenDetails.integration.test.ts

@@ -1,258 +0,0 @@
-/**
- * Integration Tests for fetchTokenDetails Tool
- *
- * Tests for comprehensive token details retrieval from DEX API platform.
- * Requires valid PRIVATE_KEY environment variable.
- *
- * Run with: npm run test:integration
- */
-
-import { AgentConfig } from '@gala-chain/launchpad-sdk';
-import { fetchTokenDetailsTool } from '../../tools/pools/index.js';
-
-describe('fetchTokenDetails Tool Integration', () => {
-  let sdk: any;
-
-  beforeAll(async () => {
-    // Skip tests if no private key available
-    if (!process.env.PRIVATE_KEY) {
-      console.warn('⚠️  Skipping integration tests: PRIVATE_KEY environment variable not set');
-      return;
-    }
-
-    // Initialize SDK with AgentConfig
-    const { sdk: initializedSdk } = await AgentConfig.quickSetup({
-      environment: (process.env.ENVIRONMENT as any) || 'development',
-      privateKey: process.env.PRIVATE_KEY,
-      timeout: 30000,
-      debug: false,
-      autoValidate: false,
-    });
-
-    sdk = initializedSdk;
-  });
-
-  afterAll(() => {
-    if (sdk) {
-      sdk.cleanup();
-    }
-  });
-
-  describe('fetchTokenDetailsTool with string tokenId', () => {
-    it('should fetch token details with string format tokenId', async () => {
-      if (!sdk) {
-        return; // Skip if SDK not initialized
-      }
-
-      // Use a known token format
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|GALA|none:none',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content).toBeDefined();
-      expect(Array.isArray(result.content)).toBe(true);
-
-      if (!result.isError) {
-        const response = JSON.parse(result.content[0].text!);
-        expect(response).toHaveProperty('symbol');
-        expect(response).toHaveProperty('decimals');
-        expect(response).toHaveProperty('name');
-      }
-    });
-
-    it('should return error for invalid tokenId format (empty)', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: '',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.isError).toBe(true);
-    });
-
-    it('should return error for non-existent token', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|NONEXISTENT|eth:0x0000000000000000000000000000000000000000',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.isError).toBe(true);
-    });
-  });
-
-  describe('fetchTokenDetailsTool with object tokenId', () => {
-    it('should fetch token details with object format tokenId', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      // Use object format
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: {
-          collection: 'Token',
-          category: 'Unit',
-          type: 'GALA',
-          additionalKey: 'none:none',
-        },
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content).toBeDefined();
-      expect(Array.isArray(result.content)).toBe(true);
-
-      if (!result.isError) {
-        const response = JSON.parse(result.content[0].text!);
-        expect(response).toHaveProperty('symbol');
-        expect(response).toHaveProperty('decimals');
-        expect(response).toHaveProperty('name');
-      }
-    });
-
-    it('should validate required fields in object format', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      // Missing additionalKey - should fail
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: {
-          collection: 'Token',
-          category: 'Unit',
-          type: 'GALA',
-          // additionalKey is missing
-        } as any,
-      });
-
-      expect(result).toBeDefined();
-      // Either returns error or throws during validation
-      expect(result.isError || !result.content).toBe(true);
-    });
-  });
-
-  describe('MCP Response Format', () => {
-    it('should return valid MCP response structure for successful token details', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|GALA|none:none',
-      });
-
-      // Validate MCP response structure
-      expect(result).toHaveProperty('content');
-      expect(Array.isArray(result.content)).toBe(true);
-
-      if (!result.isError) {
-        expect(result.content[0]).toHaveProperty('type', 'text');
-        expect(result.content[0]).toHaveProperty('text');
-
-        // Parse and validate JSON response
-        const response = JSON.parse(result.content[0].text!);
-        expect(response).toBeDefined();
-        expect(typeof response).toBe('object');
-      }
-    });
-
-    it('should return error MCP response for invalid token', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|INVALID|eth:0x0000000000000000000000000000000000000000',
-      });
-
-      // Validate error MCP response structure
-      expect(result).toBeDefined();
-      expect(result.isError).toBe(true);
-      expect(result.content).toBeDefined();
-    });
-  });
-
-  describe('Token Details Response Structure', () => {
-    it('should include all expected token detail fields when successful', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|GALA|none:none',
-      });
-
-      if (!result.isError && result.content.length > 0) {
-        const response = JSON.parse(result.content[0].text!);
-
-        // Check for key token detail fields
-        const expectedFields = ['symbol', 'decimals', 'name'];
-        expectedFields.forEach(field => {
-          expect(response).toHaveProperty(field);
-        });
-      }
-    });
-
-    it('should handle special characters in tokenId', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      // Test with colon in additionalKey
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: {
-          collection: 'Token',
-          category: 'Unit',
-          type: 'TEST',
-          additionalKey: 'eth:0xabc123def456',
-        },
-      });
-
-      expect(result).toBeDefined();
-      // Should handle without throwing errors
-      expect(result.content).toBeDefined();
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should gracefully handle network errors', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      // Try to fetch with invalid format that won't match
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Invalid|Format|Missing|Components',
-      });
-
-      expect(result).toBeDefined();
-      // Should return error response, not throw
-      if (result.isError) {
-        expect(result.content).toBeDefined();
-      }
-    });
-
-    it('should include error message in response', async () => {
-      if (!sdk) {
-        return;
-      }
-
-      const result = await fetchTokenDetailsTool.handler(sdk, {
-        tokenId: 'Token|Unit|NONEXISTENT|eth:0x0000000000000000000000000000000000000000',
-      });
-
-      if (result.isError) {
-        expect(result.content).toBeDefined();
-        expect(result.content[0]).toHaveProperty('type', 'text');
-        const errorText = result.content[0].text || '';
-        expect(errorText.length).toBeGreaterThan(0);
-      }
-    });
-  });
-});