@specverse/engine-realize 3.5.3

package/libs/instance-factories/storage/templates/postgresql/config-generator.ts

@@ -0,0 +1,54 @@
+/**
+ * PostgreSQL Configuration Generator
+ *
+ * Generates database configuration for PostgreSQL instances
+ */
+
+import type { TemplateContext } from '@specverse/engine-realize';
+
+/**
+ * Generate PostgreSQL configuration
+ */
+export default function generatePostgreSQLConfig(context: TemplateContext): string {
+  const { instance, implType } = context;
+  const config = implType.configuration || {};
+  const instanceName = instance?.name || 'default';
+
+  return `/**
+ * PostgreSQL Database Configuration
+ * Instance: ${instanceName}
+ * Generated from SpecVerse specification
+ */
+
+import { Pool, PoolConfig } from 'pg';
+
+export const ${instanceName}Config: PoolConfig = {
+  host: process.env.${instanceName.toUpperCase()}_DB_HOST || ${JSON.stringify(config.host || 'localhost')},
+  port: parseInt(process.env.${instanceName.toUpperCase()}_DB_PORT || '${config.port || 5432}'),
+  database: process.env.${instanceName.toUpperCase()}_DB_NAME || ${JSON.stringify(config.database || 'app')},
+  user: process.env.${instanceName.toUpperCase()}_DB_USER,
+  password: process.env.${instanceName.toUpperCase()}_DB_PASSWORD,
+
+  // Connection pool settings
+  min: ${config.pool?.min || 2},
+  max: ${config.pool?.max || 10},
+  idleTimeoutMillis: ${config.pool?.idleTimeoutMillis || 30000},
+  connectionTimeoutMillis: ${config.pool?.connectionTimeoutMillis || 2000},
+
+  // Performance settings
+  statement_timeout: 30000,
+  query_timeout: 30000,
+};
+
+// Create connection pool
+export const ${instanceName}Pool = new Pool(${instanceName}Config);
+
+// Handle pool errors
+${instanceName}Pool.on('error', (err) => {
+  console.error('Unexpected error on idle PostgreSQL client (${instanceName})', err);
+  process.exit(-1);
+});
+
+export default ${instanceName}Pool;
+`;
+}

package/libs/instance-factories/storage/templates/postgresql/docker-generator.ts

@@ -0,0 +1,55 @@
+/**
+ * PostgreSQL Docker Compose Generator
+ *
+ * Generates Docker Compose configuration for PostgreSQL instances
+ */
+
+import type { TemplateContext } from '@specverse/engine-realize';
+
+/**
+ * Generate Docker Compose configuration for PostgreSQL
+ */
+export default function generatePostgreSQLDocker(context: TemplateContext): string {
+  const { instance, implType } = context;
+  const config = implType.configuration || {};
+  const instanceName = instance?.name || 'postgres';
+
+  return `# PostgreSQL Docker Compose Configuration
+# Instance: ${instanceName}
+# Generated from SpecVerse specification
+
+version: '3.8'
+
+services:
+  ${instanceName}:
+    image: postgres:15-alpine
+    container_name: ${instanceName}
+    restart: unless-stopped
+
+    ports:
+      - "\${${instanceName.toUpperCase()}_DB_PORT:-${config.port || 5432}}:5432"
+
+    environment:
+      POSTGRES_DB: \${${instanceName.toUpperCase()}_DB_NAME:-app}
+      POSTGRES_USER: \${${instanceName.toUpperCase()}_DB_USER:-postgres}
+      POSTGRES_PASSWORD: \${${instanceName.toUpperCase()}_DB_PASSWORD}
+
+      # Performance settings
+      POSTGRES_MAX_CONNECTIONS: ${config.settings?.max_connections || 100}
+      POSTGRES_SHARED_BUFFERS: ${config.settings?.shared_buffers || '256MB'}
+
+    volumes:
+      - ${instanceName}_data:/var/lib/postgresql/data
+      - ./init-scripts:/docker-entrypoint-initdb.d
+
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${${instanceName.toUpperCase()}_DB_USER:-postgres}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  ${instanceName}_data:
+    driver: local
+`;
+}

package/libs/instance-factories/storage/templates/redis/config-generator.ts

@@ -0,0 +1,16 @@
+/**
+ * Redis Configuration Generator
+ */
+import type { TemplateContext } from '@specverse/engine-realize';
+
+export default function generateRedisConfig(context: TemplateContext): string {
+  const { instance } = context;
+  const instanceName = instance?.name || 'redis';
+  return `// Redis configuration for ${instanceName}
+// TODO: Implement full Redis config generator
+export const redisConfig = {
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379')
+};
+`;
+}

package/libs/instance-factories/storage/templates/redis/docker-generator.ts

@@ -0,0 +1,18 @@
+/**
+ * Redis Docker Compose Generator
+ */
+import type { TemplateContext } from '@specverse/engine-realize';
+
+export default function generateRedisDocker(context: TemplateContext): string {
+  const { instance } = context;
+  const instanceName = instance?.name || 'redis';
+  return `# Redis Docker Compose for ${instanceName}
+# TODO: Implement full Redis docker generator
+version: '3.8'
+services:
+  ${instanceName}:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+`;
+}

package/libs/instance-factories/test-generation.ts

@@ -0,0 +1,192 @@
+/**
+ * Test v3.3 Implementation Types System
+ *
+ * Tests the complete flow from spec to generated code
+ */
+
+import { createDefaultLibrary, createResolver, createCodeGenerator, loadManifest } from '@specverse/engine-realize';
+import { UnifiedSpecVerseParser } from '@specverse/engine-parser';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+async function testV33Generation() {
+  console.log('🧪 Testing v3.3 Implementation Types System\n');
+
+  try {
+    // 1. Load Implementation Type Library
+    console.log('📚 Step 1: Loading Implementation Type Library...');
+    const library = await createDefaultLibrary(process.cwd());
+    const allTypes = library.find({});
+    console.log(`   ✅ Library loaded with ${allTypes.length} implementation types`);
+
+    // List loaded types
+    allTypes.forEach(type => {
+      console.log(`   - ${type.name} v${type.version} (${type.type})`);
+    });
+    console.log();
+
+    // 2. Load Manifest
+    console.log('📄 Step 2: Loading v3.3 Manifest...');
+    const manifestPath = resolve(process.cwd(), 'examples/v33-test/fastify-prisma-manifest.yaml');
+    const manifest = loadManifest(manifestPath);
+    console.log(`   ✅ Manifest loaded: ${manifest.name}`);
+    console.log(`   - Version: ${manifest.version}`);
+    console.log(`   - Implementation Types: ${manifest.implementationTypes?.length || 0}`);
+    console.log(`   - Capability Mappings: ${Object.keys(manifest.capabilityMappings || {}).length}`);
+    console.log();
+
+    // 3. Create Resolver
+    console.log('🔍 Step 3: Creating Capability Resolver...');
+    const resolver = createResolver(library, manifest);
+    console.log(`   ✅ Resolver created`);
+    console.log();
+
+    // 4. Parse Spec
+    console.log('📝 Step 4: Parsing Test Spec...');
+    // Use a simple existing example for now
+    const specPath = resolve(process.cwd(), 'examples/01-fundamentals/01-01-basic-model.specly');
+    const specContent = readFileSync(specPath, 'utf8');
+
+    const schemaPath = resolve(process.cwd(), 'schema/SPECVERSE-SCHEMA.json');
+    const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+
+    const parser = new UnifiedSpecVerseParser(schema);
+    const parseResult = parser.parse(specContent, 'specly');
+
+    if (parseResult.errors && parseResult.errors.length > 0) {
+      console.error('   ❌ Parse errors:');
+      parseResult.errors.forEach((err: any) => {
+        console.error(`      - ${err.message}`);
+      });
+      return;
+    }
+
+    console.log(`   ✅ Spec parsed successfully`);
+    console.log(`   - Component: ${parseResult.ast?.components ? Object.keys(parseResult.ast.components)[0] : 'unknown'}`);
+    console.log(`   - Models: ${parseResult.ast?.components?.[Object.keys(parseResult.ast.components)[0]]?.models?.length || 0}`);
+    console.log(`   - Controllers: ${parseResult.ast?.components?.[Object.keys(parseResult.ast.components)[0]]?.controllers?.length || 0}`);
+
+    // Mock a deployment for testing (since basic example doesn't have one)
+    const deployment = {
+      environment: 'development',
+      instances: {
+        'apiServer': {
+          name: 'Test API Server',
+          type: 'api-server',
+          advertises: ['api.rest', 'api.rest.crud'],
+          uses: ['storage.database']
+        },
+        'database': {
+          name: 'Test Database',
+          type: 'storage',
+          advertises: ['storage.database', 'storage.prisma'],
+          uses: []
+        }
+      }
+    };
+    console.log(`   - Mocked deployment for testing`);
+    console.log(`   - Instances: ${Object.keys(deployment.instances || {}).length}`);
+    console.log();
+
+    // 5. Test Resolution
+    console.log('🔗 Step 5: Testing Capability Resolution...');
+    const apiInstance = deployment.instances?.['apiServer'];
+    if (!apiInstance) {
+      console.error('   ❌ No api-server instance found');
+      return;
+    }
+
+    console.log(`   Testing instance: ${apiInstance.name}`);
+    console.log(`   Advertises: ${apiInstance.advertises?.join(', ')}`);
+
+    const resolved = resolver.resolveForInstance(apiInstance);
+    console.log(`   ✅ Resolved ${resolved.length} implementation type(s)`);
+
+    resolved.forEach(impl => {
+      console.log(`   - ${impl.implementationType.name}`);
+      console.log(`     Capability: ${impl.capability}`);
+      console.log(`     Templates: ${Object.keys(impl.implementationType.codeTemplates).join(', ')}`);
+    });
+    console.log();
+
+    // 6. Test Code Generation
+    console.log('⚙️  Step 6: Testing Code Generation...');
+    const codeGen = createCodeGenerator({ outputDir: '/tmp/v33-test' });
+
+    // Get component data
+    const componentName = Object.keys(parseResult.ast?.components || {})[0];
+    const component = parseResult.ast?.components?.[componentName];
+    const model = component?.models?.[0];
+
+    // Mock a controller if not present
+    const controller = component?.controllers?.[0] || {
+      name: `${model?.name}Controller`,
+      path: `/api/${model?.name?.toLowerCase()}`,
+      model: model?.name,
+      endpoints: [
+        { operation: 'create', method: 'POST', path: '/' },
+        { operation: 'retrieve', method: 'GET', path: '/:id' },
+        { operation: 'update', method: 'PUT', path: '/:id' },
+        { operation: 'delete', method: 'DELETE', path: '/:id' },
+        { operation: 'list', method: 'GET', path: '/' }
+      ]
+    };
+
+    if (!model) {
+      console.error('   ❌ No model found in spec');
+      return;
+    }
+
+    console.log(`   Generating code for model: ${model.name}`);
+
+    // Test each template
+    const impl = resolved[0];
+    const templates = ['routes', 'services', 'schema'];
+
+    for (const templateName of templates) {
+      try {
+        console.log(`   Testing ${templateName} template...`);
+
+        const output = await codeGen.generateFromTemplate(
+          impl,
+          templateName,
+          {
+            spec: parseResult.ast,
+            model,
+            controller,
+            models: [model]
+          },
+          { outputDir: '/tmp/v33-test' }
+        );
+
+        console.log(`   ✅ ${templateName}: ${output.filePath}`);
+        console.log(`      Code length: ${output.code.length} characters`);
+        console.log(`      First 100 chars: ${output.code.substring(0, 100)}...`);
+      } catch (error) {
+        console.error(`   ❌ ${templateName} failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    console.log();
+
+    // 7. Summary
+    console.log('✅ All tests completed!');
+    console.log('\n📊 Summary:');
+    console.log(`   - Library: ✅ Loaded`);
+    console.log(`   - Manifest: ✅ Loaded`);
+    console.log(`   - Spec: ✅ Parsed`);
+    console.log(`   - Resolution: ✅ Working`);
+    console.log(`   - Generation: ✅ Working`);
+    console.log('\n🎉 v3.3 Implementation Types System is operational!');
+
+  } catch (error) {
+    console.error('\n❌ Test failed:', error instanceof Error ? error.message : String(error));
+    if (error instanceof Error && error.stack) {
+      console.error('\nStack trace:');
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run test
+testV33Generation();

package/libs/instance-factories/testing/templates/vitest/tests-generator.ts

@@ -0,0 +1,51 @@
+/**
+ * Vitest Test Suite Generator Wrapper
+ *
+ * Wraps the existing generate-tests.js script for use with the
+ * implementation types system.
+ *
+ * NOTE: This is a wrapper around scripts/generate-tests.js
+ * TODO: Convert generate-tests.js to native TypeScript template generator
+ *       See vitest-tests.yaml for conversion notes.
+ */
+
+import type { TemplateContext } from '@specverse/engine-realize';
+import { generateTests } from '../../../../../scripts/generate-tests.js';
+
+/**
+ * Generate test suite by delegating to the existing generator
+ */
+export default function generateTestSuite(context: TemplateContext): string {
+  const { spec, implType, outputDir } = context;
+
+  if (!spec) {
+    throw new Error('Specification is required in template context');
+  }
+
+  // Extract configuration from implementation type
+  const config = implType.configuration || {};
+
+  const options = {
+    testFramework: config.testFramework || 'vitest',
+    generateUnitTests: config.generateUnitTests !== false,
+    generateIntegrationTests: config.generateIntegrationTests !== false,
+    generateE2ETests: config.generateE2ETests !== false,
+    generateFixtures: config.generateFixtures !== false,
+    generateMocks: config.generateMocks !== false
+  };
+
+  // Call the existing generator
+  const result = generateTests(spec, outputDir || './tests', options);
+
+  // Return summary information
+  return JSON.stringify({
+    message: 'Test suite generated successfully',
+    unitTests: result.unitTests,
+    integrationTests: result.integrationTests,
+    e2eTests: result.e2eTests,
+    fixtureCount: result.fixtureCount,
+    mockCount: result.mockCount,
+    outputDir: result.outputDir,
+    files: result.files
+  }, null, 2);
+}

package/libs/instance-factories/testing/vitest-tests.yaml

@@ -0,0 +1,63 @@
+name: VitestTests
+version: "1.0.0"
+category: service
+description: "Comprehensive test suite generator with Vitest - unit, integration, and e2e tests"
+
+metadata:
+  author: "SpecVerse Team"
+  license: "MIT"
+  tags: [vitest, testing, typescript, unit, integration, e2e]
+
+compatibility:
+  specverse: "^3.3.0"
+  node: ">=18.0.0"
+
+capabilities:
+  provides:
+    - "testing.unit"
+    - "testing.integration"
+    - "testing.e2e"
+  requires:
+    - "api.rest"
+
+technology:
+  runtime: "node"
+  language: "typescript"
+  testFramework: "vitest"
+  testRunner: "vitest"
+
+dependencies:
+  dev:
+    - name: "vitest"
+      version: "^1.0.0"
+    - name: "@vitest/ui"
+      version: "^1.0.0"
+    - name: "@types/node"
+      version: "^20.8.0"
+    - name: "typescript"
+      version: "^5.2.0"
+
+codeTemplates:
+  tests:
+    engine: typescript
+    generator: "libs/instance-factories/testing/templates/vitest/tests-generator.ts"
+    outputPattern: "tests/"
+
+configuration:
+  testFramework: "vitest"
+  generateUnitTests: true
+  generateIntegrationTests: true
+  generateE2ETests: true
+  generateFixtures: true
+  generateMocks: true
+
+# NOTE: This implementation type wraps the existing generate-tests.js script
+# TODO: Future enhancement - Convert generate-tests.js to native TypeScript template generator
+#       The current script is 700+ lines and generates a complete test suite structure.
+#       Converting to native templates would require breaking it into multiple template files:
+#       - unit-tests-generator.ts (service layer unit tests)
+#       - integration-tests-generator.ts (route integration tests)
+#       - e2e-tests-generator.ts (end-to-end workflow tests)
+#       - fixtures-generator.ts (test data fixtures)
+#       - mocks-generator.ts (Prisma and EventBus mocks)
+#       - setup-generator.ts (database and server setup utilities)

package/libs/instance-factories/tools/templates/mcp/mcp-server-generator.ts

@@ -0,0 +1,136 @@
+/**
+ * MCP Server Generator
+ *
+ * Generates a Model Context Protocol server from the SpecVerse spec.
+ * Ships the core server framework as static assets, generates tool/resource
+ * registration from the spec's ToolsSupport and CLI components.
+ */
+
+import type { TemplateContext } from '@specverse/engine-realize';
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, copyFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __generatorDir = dirname(fileURLToPath(import.meta.url));
+
+export default function generateMCPServer(context: TemplateContext): string {
+  const { spec, outputDir } = context;
+
+  const mcpDir = join(outputDir || '.', 'tools', 'specverse-mcp');
+  if (!existsSync(mcpDir)) mkdirSync(mcpDir, { recursive: true });
+
+  // 1. Copy static MCP server framework
+  const staticDir = join(__generatorDir, 'static');
+  if (existsSync(staticDir)) {
+    copyRecursive(staticDir, mcpDir);
+  }
+
+  // 2. Generate tool registry from spec
+  const tools = extractMCPTools(spec);
+  const resources = extractMCPResources(spec);
+  const cliCommands = extractCLICommands(spec);
+
+  // 3. Generate a spec-driven registration file
+  const registryCode = generateToolRegistry(tools, resources, cliCommands);
+  const registryDir = join(mcpDir, 'src', 'generated');
+  if (!existsSync(registryDir)) mkdirSync(registryDir, { recursive: true });
+  writeFileSync(join(registryDir, 'spec-registry.ts'), registryCode);
+
+  return `MCP server generated in: ${mcpDir}\n  ${tools.length} tools, ${resources.length} resources, ${cliCommands.length} CLI commands`;
+}
+
+function extractMCPTools(spec: any): Array<{ name: string; description: string; isEntityTool: boolean }> {
+  const tools: Array<{ name: string; description: string; isEntityTool: boolean }> = [];
+  const components = spec?.components || [];
+  for (const component of Array.isArray(components) ? components : Object.values(components)) {
+    const models = (component as any)?.models;
+    if (!models) continue;
+    const modelList = Array.isArray(models) ? models : Object.entries(models).map(([n, d]) => ({ name: n, ...(d as any) }));
+    for (const model of modelList) {
+      if (model.name === 'MCPTool') {
+        // This is the meta-model — extract default tools from the spec description
+        tools.push(
+          { name: 'specverse-create', description: 'Create a SpecVerse specification from requirements', isEntityTool: false },
+          { name: 'specverse-analyse', description: 'Analyse existing code and extract a specification', isEntityTool: false },
+          { name: 'specverse-validate', description: 'Validate a .specly specification', isEntityTool: false },
+          { name: 'specverse-realize', description: 'Generate code from a specification', isEntityTool: false },
+          { name: 'specverse-suggest', description: 'Get improvement suggestions for a specification', isEntityTool: false },
+        );
+      }
+    }
+  }
+  if (tools.length === 0) {
+    // Default tools if no MCPTool model found
+    tools.push(
+      { name: 'specverse-validate', description: 'Validate a specification', isEntityTool: false },
+      { name: 'specverse-create', description: 'Create a specification', isEntityTool: false },
+    );
+  }
+  return tools;
+}
+
+function extractMCPResources(spec: any): Array<{ uri: string; name: string; description: string }> {
+  return [
+    { uri: 'specverse://schema', name: 'SpecVerse Schema', description: 'JSON Schema for .specly validation' },
+    { uri: 'specverse://conventions', name: 'Convention Reference', description: 'Convention syntax patterns' },
+    { uri: 'specverse://library-catalog', name: 'Library Catalog', description: 'Available SpecVerse libraries' },
+    { uri: 'specverse://prompts', name: 'Prompt Templates', description: 'AI prompt template versions' },
+  ];
+}
+
+function extractCLICommands(spec: any): string[] {
+  const commands: string[] = [];
+  const components = spec?.components || [];
+  for (const component of Array.isArray(components) ? components : Object.values(components)) {
+    const cliCommands = (component as any)?.commands;
+    if (!cliCommands) continue;
+    for (const [, rootDef] of Object.entries(cliCommands as Record<string, any>)) {
+      const subs = (rootDef as any)?.subcommands || {};
+      for (const subName of Object.keys(subs)) {
+        commands.push(subName);
+      }
+    }
+  }
+  return commands;
+}
+
+function generateToolRegistry(
+  tools: Array<{ name: string; description: string; isEntityTool: boolean }>,
+  resources: Array<{ uri: string; name: string; description: string }>,
+  cliCommands: string[]
+): string {
+  return `/**
+ * Spec-Driven MCP Registry
+ * Generated from SpecVerse self-specification.
+ *
+ * Tools, resources, and CLI command mappings derived from the spec.
+ */
+
+export const SPEC_TOOLS = ${JSON.stringify(tools, null, 2)};
+
+export const SPEC_RESOURCES = ${JSON.stringify(resources, null, 2)};
+
+export const CLI_COMMANDS = ${JSON.stringify(cliCommands, null, 2)};
+
+export function getToolByName(name: string) {
+  return SPEC_TOOLS.find(t => t.name === name);
+}
+
+export function getResourceByUri(uri: string) {
+  return SPEC_RESOURCES.find(r => r.uri === uri);
+}
+`;
+}
+
+function copyRecursive(src: string, dest: string) {
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
+      copyRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}