@specverse/engine-realize 3.5.3

package/libs/instance-factories/tools/templates/mcp/static/scripts/build-extension.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * Build Script for Extension Deployment
+ * Builds hybrid mode for VSCode extension integration
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+const verbose = process.env.VERBOSE === 'true';
+if (verbose) console.log('🔨 Building for EXTENSION deployment...');
+
+// Clean and create directories
+const distDir = join(rootDir, 'dist', 'extension');
+if (!existsSync(distDir)) {
+  mkdirSync(distDir, { recursive: true });
+}
+
+// Build TypeScript for CommonJS (VSCode compatibility)
+if (verbose) console.log('📦 Compiling TypeScript for CommonJS...');
+execSync('npx tsc --outDir dist/extension --module node16 --target es2020 --moduleResolution node16', {
+  cwd: rootDir,
+  stdio: 'inherit'
+});
+
+// Copy resources for hybrid access
+if (verbose) console.log('📁 Copying resources...');
+const resourcesDir = join(rootDir, 'resources');
+if (existsSync(resourcesDir)) {
+  execSync(`cp -r resources dist/extension/`, { cwd: rootDir, stdio: 'inherit' });
+}
+
+// Create extension-specific wrapper
+if (verbose) console.log('🔌 Creating extension wrapper...');
+const extensionWrapper = `/**
+ * VSCode Extension Wrapper for SpecVerse MCP Server
+ * Provides hybrid capabilities for extension environment
+ */
+
+const { SpecVerseCleanMCPServer } = require('./server/mcp-server.js');
+const path = require('path');
+
+class VSCodeExtensionMCPServer {
+  constructor(extensionPath) {
+    this.extensionPath = extensionPath;
+    this.config = {
+      mode: 'extension',
+      logging: true,
+      resources_path: path.join(extensionPath, 'resources'),
+      features: {
+        orchestrator: this.detectOrchestrator(),
+        fileSystemResources: true,
+        embeddedResources: true
+      }
+    };
+    
+    this.server = new SpecVerseCleanMCPServer(this.config);
+  }
+
+  detectOrchestrator() {
+    // Check if orchestrator is available in parent SpecVerse installation
+    try {
+      const orchestratorPath = path.resolve(this.extensionPath, '../../../src/orchestrator');
+      require.resolve(orchestratorPath);
+      return true;
+    } catch (error) {
+      if (verbose) console.log('Orchestrator not detected, using embedded resources only');
+      return false;
+    }
+  }
+
+  async start() {
+    return this.server.start();
+  }
+
+  getController() {
+    return this.server.getController();
+  }
+}
+
+module.exports = { VSCodeExtensionMCPServer };
+`;
+
+writeFileSync(join(distDir, 'extension-wrapper.js'), extensionWrapper);
+
+// Create extension configuration
+if (verbose) console.log('⚙️  Creating extension configuration...');
+const extensionConfig = `{
+  "mode": "extension",
+  "features": {
+    "orchestrator": "conditional",
+    "fileSystemResources": true,
+    "embeddedResources": true,
+    "hybridMode": true
+  },
+  "resourcesPath": "./resources",
+  "vscode": {
+    "activationEvents": [
+      "onLanguage:specverse",
+      "workspaceContains:**/*.specly"
+    ],
+    "capabilities": [
+      "mcp-server",
+      "resource-provider",
+      "tool-provider"
+    ]
+  }
+}`;
+
+writeFileSync(join(distDir, 'config.json'), extensionConfig);
+
+// Create package.json for extension
+const extensionPackage = {
+  name: 'specverse-mcp-extension',
+  version: '1.0.0',
+  description: 'SpecVerse MCP Server for VSCode Extension',
+  main: 'extension-wrapper.js',
+  engines: {
+    node: '>=16.0.0',
+    vscode: '^1.80.0'
+  },
+  dependencies: {
+    '@modelcontextprotocol/sdk': '^1.17.4',
+    'yaml': '^2.8.1',
+    'zod': '^3.25.76'
+  }
+};
+
+writeFileSync(join(distDir, 'package.json'), JSON.stringify(extensionPackage, null, 2));
+
+if (verbose) console.log('✅ Extension build complete!');
+if (verbose) console.log('📍 Output: dist/extension/');
+if (verbose) console.log('🔌 VSCode integration ready');
+if (verbose) console.log('🚀 Use extension-wrapper.js in VSCode extension');

package/libs/instance-factories/tools/templates/mcp/static/scripts/build-local.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Build Script for Local Deployment
+ * Builds with full orchestrator integration and file system resources
+ */
+
+import { execSync } from 'child_process';
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+const verbose = process.env.VERBOSE === 'true';
+if (verbose) console.log('🔨 Building for LOCAL deployment...');
+
+// Check if MCP SDK is available
+try {
+  execSync('npm list @modelcontextprotocol/sdk', { cwd: rootDir, stdio: 'ignore' });
+} catch (error) {
+  if (verbose) console.log('⚠️  MCP SDK not found, installing dependencies...');
+  try {
+    execSync('npm install', { cwd: rootDir, stdio: 'inherit' });
+  } catch (installError) {
+    console.error('❌ Failed to install MCP dependencies');
+    process.exit(1);
+  }
+}
+
+// Clean and create directories
+const distDir = join(rootDir, 'dist', 'local');
+if (!existsSync(distDir)) {
+  mkdirSync(distDir, { recursive: true });
+}
+
+// Build TypeScript
+if (verbose) console.log('📦 Compiling TypeScript...');
+execSync('npx tsc --outDir dist/local', {
+  cwd: rootDir,
+  stdio: 'inherit'
+});
+
+// Copy resources directory for file system access
+if (verbose) console.log('📁 Copying resources...');
+const resourcesDir = join(rootDir, 'resources');
+if (existsSync(resourcesDir)) {
+  execSync(`cp -r resources dist/local/`, { cwd: rootDir, stdio: 'inherit' });
+}
+
+// Create local-specific configuration
+if (verbose) console.log('⚙️  Creating local configuration...');
+const localConfig = `{
+  "mode": "local",
+  "features": {
+    "orchestrator": true,
+    "fileSystemResources": true,
+    "embeddedResources": false
+  },
+  "resourcesPath": "./resources"
+}`;
+
+const configPath = join(distDir, 'config.json');
+const fs = await import('fs/promises');
+await fs.writeFile(configPath, localConfig);
+
+// Make executable
+execSync('chmod +x dist/local/server/mcp-server.js', { cwd: rootDir });
+
+if (verbose) {
+  if (verbose) console.log('✅ Local build complete!');
+  if (verbose) console.log('📍 Output: dist/local/');
+  if (verbose) console.log('🚀 Run with: node dist/local/server/mcp-server.js');
+}

package/libs/instance-factories/tools/templates/mcp/static/scripts/build-web.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * Build Script for Web Deployment
+ * Builds with embedded resources, no file system access
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname, extname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+const verbose = process.env.VERBOSE === 'true';
+if (verbose) console.log('🔨 Building for WEB deployment...');
+
+// Check if MCP SDK is available
+try {
+  execSync('npm list @modelcontextprotocol/sdk', { cwd: rootDir, stdio: 'ignore' });
+} catch (error) {
+  if (verbose) console.log('⚠️  MCP SDK not found, installing dependencies...');
+  try {
+    execSync('npm install', { cwd: rootDir, stdio: 'inherit' });
+  } catch (installError) {
+    console.error('❌ Failed to install MCP dependencies');
+    process.exit(1);
+  }
+}
+
+// Clean and create directories
+const distDir = join(rootDir, 'dist', 'web');
+if (!existsSync(distDir)) {
+  mkdirSync(distDir, { recursive: true });
+}
+
+// Build TypeScript
+if (verbose) console.log('📦 Compiling TypeScript...');
+execSync('npx tsc --outDir dist/web', {
+  cwd: rootDir,
+  stdio: 'inherit'
+});
+
+// Embed resources into JavaScript
+if (verbose) console.log('🗂️  Embedding resources...');
+const resourcesDir = join(rootDir, 'resources');
+const embeddedResources = {};
+
+function embedDirectory(dir, prefix = '') {
+  if (!existsSync(dir)) {
+    console.warn(`⚠️  Resources directory not found: ${dir}`);
+    return;
+  }
+  
+  const files = readdirSync(dir);
+  for (const file of files) {
+    const fullPath = join(dir, file);
+    const stat = statSync(fullPath);
+    
+    if (stat.isDirectory()) {
+      embedDirectory(fullPath, `${prefix}${file}/`);
+    } else {
+      const key = `${prefix}${file}`;
+      try {
+        const content = readFileSync(fullPath, 'utf-8');
+        embeddedResources[key] = {
+          content,
+          mimeType: getMimeType(file),
+          size: content.length
+        };
+      } catch (error) {
+        console.warn(`⚠️  Could not read file ${fullPath}: ${error.message}`);
+      }
+    }
+  }
+}
+
+function getMimeType(filename) {
+  const ext = extname(filename).toLowerCase();
+  const mimeTypes = {
+    '.json': 'application/json',
+    '.yaml': 'application/x-yaml',
+    '.yml': 'application/x-yaml',
+    '.md': 'text/markdown',
+    '.js': 'application/javascript',
+    '.txt': 'text/plain'
+  };
+  return mimeTypes[ext] || 'text/plain';
+}
+
+embedDirectory(resourcesDir);
+
+// Create embedded resources module
+const embeddedResourcesJs = `// Embedded Resources for Web Deployment
+// Generated automatically - do not edit
+export const EMBEDDED_RESOURCES = ${JSON.stringify(embeddedResources, null, 2)};
+
+export function getEmbeddedResource(path) {
+  return EMBEDDED_RESOURCES[path];
+}
+
+export function listEmbeddedResources() {
+  return Object.keys(EMBEDDED_RESOURCES);
+}
+`;
+
+writeFileSync(join(distDir, 'embedded-resources.js'), embeddedResourcesJs);
+
+// Create web-specific configuration
+if (verbose) console.log('⚙️  Creating web configuration...');
+const webConfig = `{
+  "mode": "web",
+  "features": {
+    "orchestrator": false,
+    "fileSystemResources": false,
+    "embeddedResources": true
+  },
+  "resourcesStrategy": "embedded",
+  "embeddedResourcesCount": ${Object.keys(embeddedResources).length}
+}`;
+
+writeFileSync(join(distDir, 'config.json'), webConfig);
+
+// Create deployment manifest
+const manifest = {
+  name: 'specverse-mcp-web',
+  version: '1.0.0',
+  mode: 'web',
+  entryPoint: './server/mcp-server.js',
+  resources: {
+    strategy: 'embedded',
+    count: Object.keys(embeddedResources).length,
+    totalSize: Object.values(embeddedResources).reduce((sum, res) => sum + res.size, 0)
+  },
+  capabilities: [
+    'resources',
+    'tools',
+    'prompts'
+  ],
+  deployment: {
+    target: 'web-llm-terminal',
+    requirements: {
+      node: '>=18.0.0',
+      memory: '128MB',
+      network: 'required'
+    }
+  }
+};
+
+writeFileSync(join(distDir, 'deployment-manifest.json'), JSON.stringify(manifest, null, 2));
+
+if (verbose) console.log('✅ Web build complete!');
+if (verbose) console.log('📍 Output: dist/web/');
+if (verbose) console.log('📊 Embedded resources:', Object.keys(embeddedResources).length);
+if (verbose) console.log('💾 Total embedded size:', Object.values(embeddedResources).reduce((sum, res) => sum + res.size, 0), 'bytes');
+if (verbose) console.log('🚀 Deploy to web-based LLM terminal');

package/libs/instance-factories/tools/templates/mcp/static/scripts/copy-canonical-files.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Copy Schema Files from Canonical Location
+ * Ensures MCP server has up-to-date schemas without duplication
+ */
+
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const mcpRoot = join(__dirname, '..');
+const repoRoot = join(__dirname, '../../..');
+
+const verbose = process.env.VERBOSE === 'true';
+
+// Schemas and library catalogs are now provided through AI tools
+// Only copy essential files that aren't available through AI API
+
+// Canonical files (if any needed in future)
+const canonicalFiles = {
+  // Add any essential files here that can't be provided through AI tools
+};
+
+// No files to copy currently - schemas and catalogs provided through AI API
+if (Object.keys(canonicalFiles).length === 0) {
+  if (verbose) {
+    console.log('ℹ️  No files to copy - all resources provided through AI API');
+    console.log('📍 Schemas: Available through mcp_ai_enhance tool');
+    console.log('📍 Libraries: Available through mcp_library_suggest tool');
+    console.log('📍 Examples: Provided contextually in AI responses');
+  }
+  process.exit(0);
+}
+
+if (verbose) {
+  console.log('🎉 Canonical files copied successfully!');
+  console.log('📍 Schema Source: schema/ → resources/schemas/');
+  console.log('📍 Library Source: libs/ → resources/libraries/');
+  console.log('📍 All files now reference canonical locations');
+}

package/libs/instance-factories/tools/templates/mcp/static/scripts/test-deployments.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * Test Script for All Deployment Targets
+ * Verifies hybrid resource system works across local, web, extension, enterprise
+ */
+
+import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+console.log('🧪 Testing Hybrid Resource System Across All Deployment Targets');
+console.log('===============================================================');
+
+const results = {
+  local: { status: 'pending', metrics: null, error: null },
+  web: { status: 'pending', metrics: null, error: null },
+  extension: { status: 'pending', metrics: null, error: null },
+  enterprise: { status: 'pending', metrics: null, error: null }
+};
+
+async function testDeploymentTarget(target, command, timeout = 15000) {
+  console.log(`\n🔍 Testing ${target.toUpperCase()} deployment...`);
+  
+  return new Promise((resolve) => {
+    const child = spawn('node', command.split(' ').slice(1), {
+      cwd: rootDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, NODE_ENV: 'test' }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let resolved = false;
+
+    const timeoutId = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        child.kill('SIGTERM');
+        console.log(`   ⏰ ${target} server started successfully (timed out as expected)`);
+        results[target].status = 'success';
+        results[target].metrics = parseMetricsFromOutput(stderr);
+        resolve();
+      }
+    }, timeout);
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+      
+      // Look for success indicators
+      if (stderr.includes('initialized successfully') || 
+          stderr.includes('connected and running') ||
+          stderr.includes('Server started')) {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          child.kill('SIGTERM');
+          console.log(`   ✅ ${target} server started successfully`);
+          results[target].status = 'success';
+          results[target].metrics = parseMetricsFromOutput(stderr);
+          resolve();
+        }
+      }
+    });
+
+    child.on('error', (error) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeoutId);
+        console.log(`   ❌ ${target} server failed: ${error.message}`);
+        results[target].status = 'failed';
+        results[target].error = error.message;
+        resolve();
+      }
+    });
+
+    child.on('exit', (code, signal) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeoutId);
+        if (code === 0 || signal === 'SIGTERM') {
+          console.log(`   ✅ ${target} server exited cleanly`);
+          results[target].status = 'success';
+          results[target].metrics = parseMetricsFromOutput(stderr);
+        } else {
+          console.log(`   ❌ ${target} server exited with code ${code}`);
+          results[target].status = 'failed';
+          results[target].error = `Exit code: ${code}`;
+        }
+        resolve();
+      }
+    });
+  });
+}
+
+function parseMetricsFromOutput(output) {
+  try {
+    // Look for metrics in the output
+    const metricsMatch = output.match(/Metrics:\s*({[\s\S]*?})/);
+    if (metricsMatch) {
+      return JSON.parse(metricsMatch[1]);
+    }
+
+    // Extract provider info if available
+    const providerMatch = output.match(/resources_provider.*?mode.*?(\w+)/);
+    if (providerMatch) {
+      return { provider_mode: providerMatch[1] };
+    }
+
+    return null;
+  } catch (error) {
+    return { parse_error: error.message };
+  }
+}
+
+function validateBuildOutputs() {
+  console.log('\n📁 Validating Build Outputs...');
+  
+  const targets = ['local', 'web', 'extension', 'enterprise'];
+  const validationResults = {};
+
+  for (const target of targets) {
+    const distPath = join(rootDir, 'dist', target);
+    const configPath = join(distPath, 'config.json');
+    const serverPath = join(distPath, 'server', 'mcp-server.js');
+    
+    validationResults[target] = {
+      directory: existsSync(distPath),
+      config: existsSync(configPath),
+      server: existsSync(serverPath),
+      special: validateSpecialFiles(target, distPath)
+    };
+
+    console.log(`   ${target.toUpperCase()}:`);
+    console.log(`      Directory: ${validationResults[target].directory ? '✅' : '❌'}`);
+    console.log(`      Config: ${validationResults[target].config ? '✅' : '❌'}`);
+    console.log(`      Server: ${validationResults[target].server ? '✅' : '❌'}`);
+    console.log(`      Special: ${Object.keys(validationResults[target].special).map(k => 
+      `${k}=${validationResults[target].special[k] ? '✅' : '❌'}`).join(', ')}`);
+
+    if (validationResults[target].config) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        console.log(`      Mode: ${config.mode}`);
+      } catch (error) {
+        console.log(`      Config Error: ${error.message}`);
+      }
+    }
+  }
+
+  return validationResults;
+}
+
+function validateSpecialFiles(target, distPath) {
+  const special = {};
+  
+  switch (target) {
+    case 'web':
+      special.embeddedResources = existsSync(join(distPath, 'embedded-resources.js'));
+      special.deploymentManifest = existsSync(join(distPath, 'deployment-manifest.json'));
+      break;
+    case 'extension':
+      special.extensionWrapper = existsSync(join(distPath, 'extension-wrapper.js'));
+      special.packageJson = existsSync(join(distPath, 'package.json'));
+      break;
+    case 'enterprise':
+      special.dockerfile = existsSync(join(distPath, 'Dockerfile'));
+      special.dockerCompose = existsSync(join(distPath, 'docker-compose.yml'));
+      special.monitoring = existsSync(join(distPath, 'monitoring', 'prometheus.yml'));
+      break;
+    case 'local':
+      special.resources = existsSync(join(distPath, 'resources'));
+      break;
+  }
+
+  return special;
+}
+
+async function runTests() {
+  try {
+    // First validate build outputs
+    const buildValidation = validateBuildOutputs();
+    
+    // Test each deployment target
+    await testDeploymentTarget('local', 'node dist/local/server/mcp-server.js --mode local --silent');
+    await testDeploymentTarget('web', 'node dist/web/server/mcp-server.js --mode remote --port 3001 --silent');
+    // Extension and enterprise would need different test approaches
+    
+    // Generate test report
+    console.log('\n📊 TEST RESULTS SUMMARY');
+    console.log('=======================');
+    
+    let totalTests = 0;
+    let passedTests = 0;
+    
+    for (const [target, result] of Object.entries(results)) {
+      totalTests++;
+      const status = result.status === 'success' ? '✅ PASS' : '❌ FAIL';
+      console.log(`${target.toUpperCase().padEnd(12)} ${status}`);
+      
+      if (result.status === 'success') {
+        passedTests++;
+        if (result.metrics) {
+          console.log(`              Provider: ${result.metrics.resources_provider?.mode || 'unknown'}`);
+          console.log(`              Resources: ${result.metrics.cached_resources || 0} cached`);
+        }
+      } else if (result.error) {
+        console.log(`              Error: ${result.error}`);
+      }
+    }
+    
+    console.log(`\n📈 Overall Results: ${passedTests}/${totalTests} tests passed`);
+    
+    // Hybrid System Validation
+    console.log('\n🔄 HYBRID SYSTEM VALIDATION');
+    console.log('============================');
+    
+    const hasFilesystemMode = Object.values(results).some(r => 
+      r.metrics?.resources_provider?.mode === 'filesystem');
+    const hasEmbeddedMode = Object.values(results).some(r => 
+      r.metrics?.resources_provider?.mode === 'embedded');
+      
+    console.log(`Filesystem Mode: ${hasFilesystemMode ? '✅' : '❌'} Detected`);
+    console.log(`Embedded Mode: ${hasEmbeddedMode ? '✅' : '❌'} Detected`);
+    console.log(`Mode Detection: ${hasFilesystemMode && hasEmbeddedMode ? '✅' : '❌'} Working`);
+    
+    // Environment-specific optimizations
+    console.log('\n🎯 ENVIRONMENT OPTIMIZATIONS');
+    console.log('==============================');
+    console.log(`Web Build Embedded Resources: ${buildValidation.web?.special?.embeddedResources ? '✅' : '❌'}`);
+    console.log(`Local Build File System: ${buildValidation.local?.special?.resources ? '✅' : '❌'}`);
+    console.log(`Extension Hybrid Wrapper: ${buildValidation.extension?.special?.extensionWrapper ? '✅' : '❌'}`);
+    console.log(`Enterprise Docker Config: ${buildValidation.enterprise?.special?.dockerfile ? '✅' : '❌'}`);
+    
+    console.log('\\n🎉 HYBRID RESOURCE SYSTEM TEST COMPLETE!');
+    console.log(`📊 Success Rate: ${Math.round((passedTests / totalTests) * 100)}%`);
+    
+    return passedTests === totalTests;
+
+  } catch (error) {
+    console.error('❌ Test execution failed:', error);
+    return false;
+  }
+}
+
+// Execute tests
+runTests().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});