@specverse/engines 4.1.5 → 4.1.6

package/dist/libs/instance-factories/tools/templates/mcp/static/src/services/LibraryToolsService.js

@@ -0,0 +1,281 @@
+import { parse } from "yaml";
+import { LibrarySuggestionModel } from "../models/LibrarySuggestion.js";
+class LibraryToolsService {
+  resourcesProvider;
+  libraryCatalog = null;
+  catalogCache = /* @__PURE__ */ new Map();
+  constructor(resourcesProvider) {
+    this.resourcesProvider = resourcesProvider;
+  }
+  async getLibrarySuggestions(context) {
+    try {
+      if (!this.libraryCatalog) {
+        await this.loadLibraryCatalog();
+      }
+      if (!this.libraryCatalog) {
+        throw new Error("Library catalog not available");
+      }
+      const {
+        requirements = "",
+        scale = "business"
+      } = context;
+      const analysis = this.analyzeSuggestions(requirements, scale);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            libraries: analysis.libraries.map((lib) => ({
+              name: lib.name,
+              path: lib.path,
+              type: lib.type,
+              description: lib.description,
+              ai_description: lib.ai_description,
+              expansion_factor: lib.expansion_factor,
+              complexity_level: lib.complexity_level,
+              best_for: lib.best_for
+            })),
+            reasoning: analysis.reasoning,
+            usage_examples: analysis.usage_examples,
+            total_suggestions: analysis.libraries.length,
+            scale_optimization: scale
+          }, null, 2)
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error generating library suggestions: ${error instanceof Error ? error.message : String(error)}`
+        }],
+        isError: true
+      };
+    }
+  }
+  analyzeSuggestions(projectContext, scale) {
+    if (!this.libraryCatalog) {
+      return {
+        libraries: [],
+        reasoning: "Library catalog not available",
+        usage_examples: []
+      };
+    }
+    const suggestions = [];
+    const reasoningParts = [];
+    const usageExamples = [];
+    const contextLower = projectContext.toLowerCase();
+    const allLibraries = this.getAllLibraries();
+    const domainAnalysis = this.analyzeDomain(contextLower, allLibraries);
+    if (domainAnalysis.library) {
+      suggestions.push(domainAnalysis.library);
+      reasoningParts.push(domainAnalysis.reasoning);
+      usageExamples.push(domainAnalysis.usage);
+    }
+    const techAnalysis = this.analyzeTechnology(contextLower, allLibraries);
+    if (techAnalysis.library && !suggestions.find((s) => s.name === techAnalysis.library.name)) {
+      suggestions.push(techAnalysis.library);
+      reasoningParts.push(techAnalysis.reasoning);
+      usageExamples.push(techAnalysis.usage);
+    }
+    const deploymentAnalysis = this.analyzeDeployment(scale, allLibraries);
+    if (deploymentAnalysis.library && !suggestions.find((s) => s.name === deploymentAnalysis.library.name)) {
+      suggestions.push(deploymentAnalysis.library);
+      reasoningParts.push(deploymentAnalysis.reasoning);
+      usageExamples.push(deploymentAnalysis.usage);
+    }
+    const authAnalysis = this.analyzeAuthentication(contextLower, allLibraries);
+    if (authAnalysis.library && !suggestions.find((s) => s.name === authAnalysis.library.name)) {
+      suggestions.push(authAnalysis.library);
+      reasoningParts.push(authAnalysis.reasoning);
+      usageExamples.push(authAnalysis.usage);
+    }
+    if (suggestions.length === 0) {
+      const defaults = allLibraries.filter((lib) => this.isGeneralPurpose(lib) || this.matchesScale(lib, scale)).slice(0, 2);
+      suggestions.push(...defaults);
+      reasoningParts.push("General-purpose libraries for common patterns");
+      usageExamples.push('import:\\n  - from: "@specverse/types/examples"\\n    models: [User, BaseEntity]');
+    }
+    suggestions.sort((a, b) => {
+      const aScore = a.matchesContext(projectContext, scale);
+      const bScore = b.matchesContext(projectContext, scale);
+      return bScore - aScore;
+    });
+    return {
+      libraries: suggestions.slice(0, 5),
+      // Top 5 suggestions
+      reasoning: reasoningParts.join("; "),
+      usage_examples: usageExamples
+    };
+  }
+  async loadLibraryCatalog() {
+    try {
+      const catalogContent = await this.resourcesProvider.getResourceContent("specverse://libraries/catalog");
+      this.libraryCatalog = parse(catalogContent);
+      this.cacheLibraryModels();
+    } catch (error) {
+      console.error("Failed to load library catalog:", error);
+      this.libraryCatalog = this.createEmptyLibraryCatalog();
+    }
+  }
+  cacheLibraryModels() {
+    if (!this.libraryCatalog) return;
+    const allLibraries = [
+      ...Object.values(this.libraryCatalog.deployments || {}),
+      ...Object.values(this.libraryCatalog.domains || {}),
+      ...Object.values(this.libraryCatalog.manifests || {}),
+      ...Object.values(this.libraryCatalog.types || {})
+    ];
+    for (const library of allLibraries) {
+      try {
+        const model = LibrarySuggestionModel.create(library);
+        this.catalogCache.set(library.name, model);
+      } catch (error) {
+        console.warn(`Failed to cache library ${library.name}:`, error);
+      }
+    }
+  }
+  getAllLibraries() {
+    return Array.from(this.catalogCache.values());
+  }
+  analyzeDomain(context, libraries) {
+    if (context.includes("ecommerce") || context.includes("store") || context.includes("shop")) {
+      const ecommerce = libraries.find((lib) => lib.name.includes("ecommerce"));
+      if (ecommerce) {
+        return {
+          library: ecommerce,
+          reasoning: "E-commerce domain detected",
+          usage: 'import:\\n  - from: "@specverse/domains/ecommerce"\\n    models: [Product, Order, Customer]'
+        };
+      }
+    }
+    if (context.includes("healthcare") || context.includes("medical") || context.includes("patient")) {
+      const healthcare = libraries.find((lib) => lib.name.includes("healthcare"));
+      if (healthcare) {
+        return {
+          library: healthcare,
+          reasoning: "Healthcare domain detected",
+          usage: 'import:\\n  - from: "@specverse/domains/healthcare"\\n    models: [Patient, Provider, Appointment]'
+        };
+      }
+    }
+    return { reasoning: "No specific domain patterns detected", usage: "" };
+  }
+  analyzeTechnology(context, libraries) {
+    if (context.includes("nextjs") || context.includes("next.js") || context.includes("react")) {
+      const nextjs = libraries.find((lib) => lib.name.includes("nextjs"));
+      if (nextjs) {
+        return {
+          library: nextjs,
+          reasoning: "Next.js framework detected",
+          usage: 'import:\\n  - from: "@specverse/manifests/nextjs"\\n    manifests: [nextjs-config]'
+        };
+      }
+    }
+    if (context.includes("postgresql") || context.includes("postgres")) {
+      const postgres = libraries.find((lib) => lib.name.includes("postgresql"));
+      if (postgres) {
+        return {
+          library: postgres,
+          reasoning: "PostgreSQL database detected",
+          usage: 'import:\\n  - from: "@specverse/manifests/postgresql"\\n    manifests: [postgres-config]'
+        };
+      }
+    }
+    return { reasoning: "No specific technology patterns detected", usage: "" };
+  }
+  analyzeDeployment(scale, libraries) {
+    switch (scale) {
+      case "personal":
+        const personal = libraries.find((lib) => lib.name.includes("jamstack") || lib.name.includes("monolith"));
+        if (personal) {
+          return {
+            library: personal,
+            reasoning: "Personal scale: simple deployment recommended",
+            usage: `import:\\n  - from: "@specverse/deployments/${personal.name}"\\n    deployments: [development]`
+          };
+        }
+        break;
+      case "enterprise":
+        const enterprise = libraries.find((lib) => lib.name.includes("enterprise") || lib.name.includes("microservices"));
+        if (enterprise) {
+          return {
+            library: enterprise,
+            reasoning: "Enterprise scale: distributed architecture recommended",
+            usage: `import:\\n  - from: "@specverse/deployments/${enterprise.name}"\\n    deployments: [production-cluster]`
+          };
+        }
+        break;
+      default:
+        const business = libraries.find((lib) => lib.name.includes("microservices") || lib.name.includes("monolith"));
+        if (business) {
+          return {
+            library: business,
+            reasoning: "Business scale: scalable deployment recommended",
+            usage: `import:\\n  - from: "@specverse/deployments/${business.name}"\\n    deployments: [production]`
+          };
+        }
+        break;
+    }
+    return { reasoning: "No deployment pattern match found", usage: "" };
+  }
+  analyzeAuthentication(context, libraries) {
+    if (context.includes("authentication") || context.includes("auth") || context.includes("login")) {
+      const oauth = libraries.find((lib) => lib.name.includes("oauth"));
+      if (oauth) {
+        return {
+          library: oauth,
+          reasoning: "Authentication features detected",
+          usage: 'import:\\n  - from: "@specverse/manifests/oauth"\\n    manifests: [oauth-config]'
+        };
+      }
+    }
+    return { reasoning: "No authentication patterns detected", usage: "" };
+  }
+  isGeneralPurpose(library) {
+    return library.name.includes("examples") || library.name.includes("lib") || library.type === "type";
+  }
+  matchesScale(library, scale) {
+    const scaleComplexity = this.getScaleComplexity(scale);
+    const libComplexity = this.getComplexityScore(library.complexity_level);
+    return Math.abs(libComplexity - scaleComplexity) <= 1;
+  }
+  getScaleComplexity(scale) {
+    switch (scale) {
+      case "personal":
+        return 1;
+      case "business":
+        return 2;
+      case "enterprise":
+        return 3;
+      default:
+        return 2;
+    }
+  }
+  getComplexityScore(complexity) {
+    switch (complexity) {
+      case "low":
+        return 1;
+      case "medium":
+        return 2;
+      case "high":
+        return 3;
+      default:
+        return 2;
+    }
+  }
+  createEmptyLibraryCatalog() {
+    return {
+      version: "3.1.0",
+      generated_at: /* @__PURE__ */ new Date(),
+      generated_from: "embedded",
+      ai_optimization: false,
+      total_libraries: 0,
+      deployments: {},
+      domains: {},
+      manifests: {},
+      types: {}
+    };
+  }
+}
+export {
+  LibraryToolsService
+};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/services/OrchestratorBridge.js

@@ -0,0 +1,409 @@
+class OrchestratorBridge {
+  config;
+  eventEmitter;
+  capabilities;
+  orchestrator = null;
+  initialized = false;
+  constructor(config, eventEmitter) {
+    this.config = config;
+    this.eventEmitter = eventEmitter;
+    this.capabilities = {
+      hasFullOrchestrator: false,
+      availableOperations: [],
+      sessionSupport: false,
+      inferenceEngine: false
+    };
+  }
+  /**
+   * Initialize orchestrator bridge with environment detection
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      if (this.config.autoDetect !== false) {
+        await this.detectOrchestrator();
+      }
+      if (this.config.enabled && this.capabilities.hasFullOrchestrator) {
+        await this.initializeFullOrchestrator();
+      } else {
+        await this.initializeFallbackMode();
+      }
+      this.initialized = true;
+      this.eventEmitter.emit("orchestrator-initialized", {
+        type: "orchestrator-initialized",
+        capabilities: this.capabilities
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.config.logging) {
+        console.warn(`Orchestrator initialization failed: ${errorMessage}`);
+      }
+      await this.initializeFallbackMode();
+      this.initialized = true;
+    }
+  }
+  /**
+   * Execute orchestrator operation
+   */
+  async execute(context) {
+    if (!this.initialized) {
+      throw new Error("Orchestrator bridge not initialized");
+    }
+    const startTime = Date.now();
+    try {
+      let result;
+      if (this.capabilities.hasFullOrchestrator && this.orchestrator) {
+        result = await this.executeWithFullOrchestrator(context);
+      } else {
+        result = await this.executeWithFallback(context);
+      }
+      const executionTime = Date.now() - startTime;
+      result.executionTime = executionTime;
+      this.eventEmitter.emit("orchestrator-execution-completed", {
+        type: "orchestrator-execution-completed",
+        operation: context.operation,
+        executionTime,
+        success: result.success
+      });
+      return result;
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.eventEmitter.emit("orchestrator-execution-failed", {
+        type: "orchestrator-execution-failed",
+        operation: context.operation,
+        error: errorMessage,
+        executionTime
+      });
+      return {
+        success: false,
+        content: "",
+        operation: context.operation,
+        executionTime,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Get orchestrator capabilities
+   */
+  getCapabilities() {
+    return { ...this.capabilities };
+  }
+  /**
+   * Check if orchestrator is available
+   */
+  isAvailable() {
+    return this.initialized && (this.capabilities.hasFullOrchestrator || true);
+  }
+  /**
+   * Get supported operations
+   */
+  getSupportedOperations() {
+    return [...this.capabilities.availableOperations];
+  }
+  // Private methods
+  /**
+   * Detect orchestrator availability in current environment
+   */
+  async detectOrchestrator() {
+    try {
+      const orchestratorPath = this.config.orchestratorPath || "@specverse/engine-ai";
+      try {
+        const orchestratorModule = await import(orchestratorPath);
+        if (orchestratorModule.SpecVerseOrchestrator) {
+          this.capabilities.hasFullOrchestrator = true;
+          if (this.config.logging && this.config.mode !== "local") {
+            console.log("Full orchestrator detected via import");
+          }
+          return;
+        }
+      } catch (importError) {
+      }
+      const { existsSync } = await import("fs");
+      const { resolve, join } = await import("path");
+      const possiblePaths = [
+        resolve(process.cwd(), "../../../src/orchestrator"),
+        resolve(process.cwd(), "../../src/orchestrator"),
+        resolve(process.cwd(), "../src/orchestrator"),
+        resolve(process.cwd(), "src/orchestrator"),
+        join(process.cwd(), "../../dist/orchestrator")
+      ];
+      for (const path of possiblePaths) {
+        if (existsSync(path)) {
+          this.capabilities.hasFullOrchestrator = true;
+          this.config.orchestratorPath = path;
+          if (this.config.logging && this.config.mode !== "local") {
+            console.log(`Orchestrator detected at: ${path}`);
+          }
+          return;
+        }
+      }
+      try {
+        const { execSync } = await import("child_process");
+        execSync("specverse --version", { stdio: "pipe" });
+        this.capabilities.hasFullOrchestrator = true;
+        if (this.config.logging && this.config.mode !== "local") {
+          console.log("Global SpecVerse CLI detected");
+        }
+        return;
+      } catch (cliError) {
+      }
+      if (this.config.logging && this.config.mode !== "local") {
+        console.log("Full orchestrator not detected, using fallback mode");
+      }
+      this.capabilities.hasFullOrchestrator = false;
+    } catch (error) {
+      if (this.config.logging) {
+        console.warn(`Orchestrator detection failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      this.capabilities.hasFullOrchestrator = false;
+    }
+  }
+  /**
+   * Initialize full orchestrator with all capabilities
+   */
+  async initializeFullOrchestrator() {
+    try {
+      let orchestratorModule;
+      const possiblePaths = [
+        this.config.orchestratorPath,
+        // User-specified path
+        "@specverse/engine-ai",
+        // npm package (primary)
+        "../../dist/orchestrator/index.js"
+        // local package path (fallback)
+      ].filter(Boolean);
+      for (const path of possiblePaths) {
+        if (!path) continue;
+        try {
+          orchestratorModule = await import(path);
+          if (orchestratorModule.SpecVerseOrchestrator) {
+            if (this.config.logging) {
+              console.log(`Successfully loaded orchestrator from: ${path}`);
+            }
+            break;
+          }
+        } catch (error) {
+          if (this.config.logging) {
+            console.debug(`Failed to load orchestrator from ${path}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+          continue;
+        }
+      }
+      if (!orchestratorModule) {
+        throw new Error("Could not find orchestrator module in any of the expected locations");
+      }
+      if (!orchestratorModule.SpecVerseOrchestrator) {
+        throw new Error("SpecVerseOrchestrator not found in module");
+      }
+      this.orchestrator = new orchestratorModule.SpecVerseOrchestrator();
+      await this.orchestrator.initialize();
+      this.capabilities = {
+        hasFullOrchestrator: true,
+        availableOperations: ["analyse", "create", "infer", "materialise", "realize"],
+        workingDirectory: this.config.workingDirectory || process.cwd(),
+        sessionSupport: true,
+        inferenceEngine: true
+      };
+      if (this.config.logging) {
+        if (this.config.logging && this.config.mode !== "local") {
+          console.log("Full orchestrator initialized successfully");
+        }
+      }
+      if (this.config.logging) {
+        if (this.config.logging && this.config.mode !== "local") {
+          console.log(`Available operations: ${this.capabilities.availableOperations.join(", ")}`);
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to initialize full orchestrator: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Initialize fallback mode with limited capabilities
+   */
+  async initializeFallbackMode() {
+    this.capabilities = {
+      hasFullOrchestrator: false,
+      availableOperations: ["create", "analyse"],
+      // Basic operations available via prompts
+      workingDirectory: this.config.workingDirectory || process.cwd(),
+      sessionSupport: false,
+      inferenceEngine: false
+    };
+    if (this.config.logging) {
+      if (this.config.logging && this.config.mode !== "local") {
+        console.log("Orchestrator bridge initialized in fallback mode");
+      }
+    }
+    if (this.config.logging) {
+      if (this.config.logging && this.config.mode !== "local") {
+        console.log(`Limited operations: ${this.capabilities.availableOperations.join(", ")}`);
+      }
+    }
+  }
+  /**
+   * Execute operation with full orchestrator
+   */
+  async executeWithFullOrchestrator(context) {
+    try {
+      const orchestrationContext = {
+        operation: context.operation,
+        input: context.input,
+        inputPath: context.inputPath,
+        inputType: context.inputType,
+        outputPath: context.outputPath,
+        framework: context.framework,
+        scale: context.scale || "business",
+        interactive: context.interactive || false,
+        sessionId: context.sessionId
+      };
+      if (this.config.logging) {
+        if (this.config.logging && this.config.mode !== "local") {
+          console.log(`Executing ${context.operation} with full orchestrator...`);
+        }
+      }
+      const result = await this.orchestrator.execute(orchestrationContext);
+      return {
+        success: true,
+        content: result.content,
+        operation: context.operation,
+        provider: result.provider,
+        sessionId: result.sessionId,
+        executionTime: 0,
+        // Will be set by caller
+        metadata: result.metadata
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.config.logging) {
+        console.error(`Full orchestrator execution failed: ${errorMessage}`);
+      }
+      return {
+        success: false,
+        content: "",
+        operation: context.operation,
+        executionTime: 0,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute operation with fallback implementation
+   */
+  async executeWithFallback(context) {
+    if (this.config.logging) {
+      if (this.config.logging && this.config.mode !== "local") {
+        console.log(`Executing ${context.operation} in fallback mode...`);
+      }
+    }
+    switch (context.operation) {
+      case "create":
+        return this.executeFallbackCreate(context);
+      case "analyse":
+        return this.executeFallbackAnalyse(context);
+      case "infer":
+        return this.executeFallbackInfer(context);
+      default:
+        return {
+          success: false,
+          content: "",
+          operation: context.operation,
+          executionTime: 0,
+          error: `Operation '${context.operation}' not supported in fallback mode. Full orchestrator required.`
+        };
+    }
+  }
+  async executeFallbackCreate(context) {
+    const content = `# SpecVerse Creation (Fallback Mode)
+
+**Requirements**: ${context.input || "No requirements provided"}
+**Scale**: ${context.scale || "business"}
+**Framework**: ${context.framework || "auto-detect"}
+
+## Next Steps
+
+This operation requires the full SpecVerse orchestrator for AI-powered specification creation. 
+
+In fallback mode, you can:
+1. Use the \`get_creation_prompt\` MCP tool to get an expanded prompt
+2. Use that prompt with your AI assistant to create specifications
+3. Use the SpecVerse CLI locally for full orchestrator capabilities
+
+## Fallback Specification Template
+
+\`\`\`yaml
+components:
+  ${context.framework || "Application"}Component:
+    models:
+      # Define your models here based on requirements
+      ExampleModel:
+        attributes:
+          name: String required
+          description: String optional
+        relationships:
+          # Add relationships as needed
+\`\`\`
+
+**Note**: For full AI-powered creation, install the complete SpecVerse toolchain locally.`;
+    return {
+      success: true,
+      content,
+      operation: context.operation,
+      executionTime: 0,
+      metadata: {
+        scale: context.scale,
+        framework: context.framework,
+        processingTime: 1
+      }
+    };
+  }
+  async executeFallbackAnalyse(context) {
+    const content = `# SpecVerse Analysis (Fallback Mode)
+
+**Target**: ${context.inputPath || context.input || "No input provided"}
+**Framework**: ${context.framework || "auto-detect"}
+
+## Analysis Summary
+
+This operation requires the full SpecVerse orchestrator for AI-powered codebase analysis.
+
+In fallback mode, you can:
+1. Use the \`get_analysis_prompt\` MCP tool to get an expanded analysis prompt
+2. Use that prompt with your AI assistant to analyze codebases
+3. Install the complete SpecVerse toolchain for full orchestrator capabilities
+
+## Manual Analysis Steps
+
+1. **Identify Models**: Look for data structures, entities, classes
+2. **Map Relationships**: Identify how models relate to each other  
+3. **Find Controllers**: Locate API endpoints, request handlers
+4. **Discover Services**: Find business logic, processing functions
+5. **Map Events**: Identify event publishing and handling
+
+**Note**: For full AI-powered analysis, install the complete SpecVerse toolchain locally.`;
+    return {
+      success: true,
+      content,
+      operation: context.operation,
+      executionTime: 0,
+      metadata: {
+        framework: context.framework,
+        processingTime: 1
+      }
+    };
+  }
+  async executeFallbackInfer(context) {
+    return {
+      success: false,
+      content: "",
+      operation: context.operation,
+      executionTime: 0,
+      error: "Inference operation requires the full SpecVerse orchestrator with inference engine. Please install the complete SpecVerse toolchain."
+    };
+  }
+}
+export {
+  OrchestratorBridge
+};