@specverse/engines 4.3.4 → 5.0.0

package/libs/instance-factories/tools/templates/mcp/static/src/tests/unit/CLIProxyService.test.ts

@@ -1,189 +0,0 @@
-/**
- * CLIProxyService Unit Tests
- * Tests for dynamic CLI integration functionality
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CLIProxyService } from '../../services/CLIProxyService.js';
-
-// Mock both possible import paths (published package and local)
-const mockCapabilities = {
-  coreCommands: [
-    {
-      command: 'validate',
-      description: 'Validate a SpecVerse specification',
-      args: '<file>',
-      options: '-v, --verbose'
-    },
-    {
-      command: 'infer',
-      description: 'Generate complete specification using AI',
-      args: '<file>',
-      options: ''
-    }
-  ],
-  groupedCommands: [
-    {
-      command: 'gen yaml',
-      group: 'gen',
-      subcommand: 'yaml',
-      description: 'Generate YAML from SpecVerse specification',
-      args: '<file>',
-      category: 'SpecVerse Generation'
-    }
-  ],
-  aiCommands: [
-    {
-      command: 'ai',
-      description: 'AI prompt building commands',
-      args: '<action> [operation]',
-      options: ''
-    },
-    {
-      command: 'ai template',
-      description: 'AI template for SpecVerse specifications',
-      args: '<operation>',
-      options: ''
-    }
-  ]
-};
-
-const mockAPI = {
-  getAllCliCapabilities: vi.fn(() => mockCapabilities),
-  executeCliCommand: vi.fn(async (command, args) => {
-    if (command.includes('validate')) {
-      return {
-        status: 'success',
-        message: 'Validation successful',
-        file: args.file || 'test.specly',
-        timestamp: new Date().toISOString()
-      };
-    }
-    throw new Error(`Command not mocked: ${command}`);
-  }),
-  getCliPath: vi.fn(() => '/mock/path/to/cli') as ReturnType<typeof vi.fn<[], string | null>>
-};
-
-// Mock the published package
-vi.mock('@specverse/entities', () => mockAPI);
-
-// Mock the local development path
-vi.mock('../../../../../dist/index.js', () => mockAPI);
-
-describe('CLIProxyService', () => {
-  let service: CLIProxyService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    service = new CLIProxyService();
-  });
-
-  describe('capability discovery', () => {
-    it('should discover CLI capabilities', async () => {
-      const capabilities = await service.discoverCapabilities();
-      
-      expect(capabilities).toHaveProperty('coreCommands');
-      expect(capabilities).toHaveProperty('groupedCommands'); 
-      expect(capabilities).toHaveProperty('aiCommands');
-      expect(capabilities.coreCommands.length).toBeGreaterThan(0);
-    });
-
-    it('should cache capabilities for performance', async () => {
-      // First call
-      await service.discoverCapabilities();
-      // Second call (should use cache)
-      await service.discoverCapabilities();
-
-      // Should only call once due to caching
-      expect(mockAPI.getAllCliCapabilities).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('MCP tool generation', () => {
-    it('should generate MCP tools from CLI capabilities', async () => {
-      const tools = await service.generateMCPTools();
-      
-      expect(tools).toBeInstanceOf(Array);
-      expect(tools.length).toBeGreaterThan(0);
-      
-      // Check tool structure
-      const validateTool = tools.find(t => t.name === 'specverse_validate');
-      expect(validateTool).toBeDefined();
-      expect(validateTool?.description).toContain('Validate');
-      expect(validateTool?.inputSchema).toHaveProperty('properties');
-    });
-
-    it('should generate AI tools with proper schemas', async () => {
-      const tools = await service.generateMCPTools();
-      
-      const aiTemplateTool = tools.find(t => t.name === 'specverse_ai_template');
-      expect(aiTemplateTool).toBeDefined();
-      expect(aiTemplateTool?.inputSchema.properties).toHaveProperty('operation');
-      expect(aiTemplateTool?.inputSchema.required).toContain('operation');
-    });
-  });
-
-  describe('command execution', () => {
-    it('should execute CLI commands and return structured results', async () => {
-      const result = await service.executeCommand('specverse_validate', { file: 'test.specly' });
-      
-      expect(result).toHaveProperty('content');
-      expect(result.content).toBeInstanceOf(Array);
-      expect(result.content[0]).toHaveProperty('type', 'text');
-      
-      // Parse the JSON result
-      const textContent = result.content[0].text;
-      expect(textContent).toBeDefined();
-      const jsonResult = JSON.parse(textContent!);
-      expect(jsonResult).toHaveProperty('status', 'success');
-      expect(jsonResult).toHaveProperty('file', 'test.specly');
-    });
-
-    it('should handle command failures gracefully', async () => {
-      const result = await service.executeCommand('specverse_nonexistent', {});
-      
-      expect(result).toHaveProperty('isError', true);
-      expect(result.content[0].text).toContain('error');
-    });
-
-    it('should handle CLI not found scenario', async () => {
-      // Mock CLI not found
-      mockAPI.getCliPath.mockReturnValueOnce(null);
-
-      const serviceWithoutCli = new CLIProxyService();
-      const result = await serviceWithoutCli.executeCommand('specverse_validate', {});
-
-      expect(result).toHaveProperty('isError', true);
-      expect(result.content[0].text).toContain('CLI not found');
-    });
-  });
-
-  describe('tool name mapping', () => {
-    it('should map MCP tool names back to CLI commands', async () => {
-      const service = new CLIProxyService();
-      
-      // Access private method for testing (TypeScript will complain, but it works)
-      const mapMethod = (service as any).mapToolNameToCommand;
-      
-      expect(mapMethod('specverse_validate')).toBe('validate');
-      expect(mapMethod('specverse_gen_yaml')).toBe('gen yaml');
-      expect(mapMethod('specverse_ai_template')).toBe('ai template');
-    });
-  });
-
-  describe('error scenarios', () => {
-    it('should handle discovery failures', async () => {
-      // Use the already mocked function
-      mockAPI.getAllCliCapabilities.mockImplementationOnce(() => {
-        throw new Error('Discovery failed');
-      });
-
-      const capabilities = await service.discoverCapabilities();
-
-      // Should return empty capabilities on failure
-      expect(capabilities.coreCommands).toEqual([]);
-      expect(capabilities.groupedCommands).toEqual([]);
-      expect(capabilities.aiCommands).toEqual([]);
-    });
-  });
-});

package/libs/instance-factories/tools/templates/mcp/static/src/tests/unit/ResourcesProviderService.test.ts

@@ -1,89 +0,0 @@
-/**
- * ResourcesProviderService Unit Tests
- * Clean implementation test suite
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ResourcesProviderService } from '../../services/ResourcesProviderService.js';
-
-describe('ResourcesProviderService', () => {
-  let service: ResourcesProviderService;
-
-  beforeEach(() => {
-    service = new ResourcesProviderService();
-  });
-
-  describe('initialization', () => {
-    it('should initialize without errors', async () => {
-      await expect(service.initializeResources()).resolves.not.toThrow();
-    });
-
-    it('should list resources after initialization', async () => {
-      await service.initializeResources();
-      const resources = await service.listResources();
-      
-      expect(resources).toBeInstanceOf(Array);
-      expect(resources.length).toBeGreaterThan(0);
-      expect(resources[0]).toHaveProperty('uri');
-      expect(resources[0]).toHaveProperty('name');
-      expect(resources[0]).toHaveProperty('description');
-      expect(resources[0]).toHaveProperty('mimeType');
-    });
-  });
-
-  describe('resource management', () => {
-    beforeEach(async () => {
-      await service.initializeResources();
-    });
-
-    it('should check resource availability', () => {
-      expect(service.isResourceAvailable('specverse://examples/chat-prompts')).toBe(true);
-      expect(service.isResourceAvailable('nonexistent://resource')).toBe(false);
-    });
-
-    it('should handle unknown resource URIs', async () => {
-      await expect(service.getResourceContent('unknown://resource'))
-        .rejects.toThrow('Resource not found');
-    });
-
-    it('should track cached resource count', () => {
-      const count = service.getCachedResourceCount();
-      expect(count).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe('resource reading', () => {
-    beforeEach(async () => {
-      await service.initializeResources();
-    });
-
-    it('should return proper MCP tool result structure', async () => {
-      // Mock successful resource read since we don't have actual files in test
-      const result = await service.readResource('specverse://examples/chat-prompts').catch(err => ({
-        content: [{ type: 'text' as const, text: err.message }],
-        isError: true
-      }));
-
-      expect(result).toHaveProperty('content');
-      expect(result.content).toBeInstanceOf(Array);
-      expect(result.content[0]).toHaveProperty('type');
-    });
-  });
-
-  describe('error handling', () => {
-    beforeEach(async () => {
-      await service.initializeResources();
-    });
-
-    it('should handle file system errors gracefully', async () => {
-      const result = await service.readResource('specverse://examples/chat-prompts');
-      
-      if (result.isError) {
-        expect(result.content[0].type).toBe('text');
-        expect(result.content[0].text).toContain('Error reading resource');
-      } else {
-        expect(result.content[0].type).toBe('resource');
-      }
-    });
-  });
-});

package/libs/instance-factories/tools/templates/mcp/static/src/types/index.ts

@@ -1,110 +0,0 @@
-/**
- * Clean Implementation - Core Types
- * Generated from extracted SpecVerse specification
- */
-
-export interface SpecVerseResource {
-  uri: string;
-  name: string;
-  description: string;
-  mimeType: string;
-  content?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface LibrarySuggestion {
-  name: string;
-  path: string;
-  type: 'deployment' | 'domain' | 'manifest' | 'type' | 'standard';
-  description: string;
-  ai_description: string;
-  expansion_factor: number;
-  complexity_level: 'low' | 'medium' | 'high';
-  best_for: string[];
-}
-
-export interface StandardPrompt {
-  name: string;
-  version: string;
-  description: string;
-  author: string;
-  tags: string[];
-  system_role: string;
-  system_context: string;
-  system_capabilities: string[];
-  system_constraints: string[];
-  user_template: string;
-  max_tokens: number;
-  temperature: number;
-}
-
-export interface LibraryCatalog {
-  version: string;
-  generated_at: Date;
-  generated_from: string;
-  ai_optimization: boolean;
-  total_libraries: number;
-  deployments: Record<string, LibrarySuggestion>;
-  domains: Record<string, LibrarySuggestion>;
-  manifests: Record<string, LibrarySuggestion>;
-  types: Record<string, LibrarySuggestion>;
-}
-
-export interface MCPToolResult {
-  content: Array<{
-    type: 'text' | 'resource';
-    text?: string;
-    resource?: SpecVerseResource;
-  }>;
-  isError?: boolean;
-}
-
-export interface PromptContext {
-  requirements?: string;
-  scale?: 'personal' | 'business' | 'enterprise';
-  preferredTech?: string;
-  projectType?: string;
-  frameworkHint?: string;
-  targetFramework?: string;
-  deploymentType?: string;  // Added for Phase 3
-  implementationScope?: string;  // Added for Phase 3
-}
-
-// Event Types
-export interface ServerStartedEvent {
-  mode: string;
-  port?: number;
-  pid: number;
-}
-
-export interface ToolCalledEvent {
-  toolName: string;
-  arguments: Record<string, any>;
-  executionTime: number;
-}
-
-export interface ResourceRequestedEvent {
-  uri: string;
-  requestTime: Date;
-}
-
-export interface ErrorOccurredEvent {
-  operation: string;
-  error: string;
-  context?: Record<string, any>;
-}
-
-// Configuration Types
-export type MCPServerMode = 'local' | 'remote';
-
-export interface MCPServerConfig {
-  mode: MCPServerMode;
-  port?: number;
-  host?: string;
-  logging?: boolean;
-  resources_path?: string;
-  workingDirectory?: string;
-  features?: {
-    orchestrator?: boolean;
-  };
-}

package/libs/instance-factories/tools/templates/mcp/static/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": false,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "resolveJsonModule": true,
-    "allowImportingTsExtensions": false,
-    "noImplicitAny": false
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}