@specverse/engine-realize 3.5.3

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

@@ -0,0 +1,189 @@
+/**
+ * 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/engine-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

@@ -0,0 +1,89 @@
+/**
+ * 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

@@ -0,0 +1,110 @@
+/**
+ * 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

@@ -0,0 +1,28 @@
+{
+  "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"
+  ]
+}