@specverse/engines 4.1.5 → 4.1.6

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

@@ -0,0 +1,172 @@
+import { SpecVerseResourceModel } from "../models/SpecVerseResource.js";
+class EmbeddedResourcesAdapter {
+  resourceCatalog = /* @__PURE__ */ new Map();
+  embeddedResources;
+  isInitialized = false;
+  constructor(embeddedResources) {
+    this.embeddedResources = embeddedResources;
+  }
+  async initializeResources() {
+    if (this.isInitialized) {
+      return;
+    }
+    const resources = [
+      {
+        uri: "specverse://schema/json",
+        name: "SpecVerse v3.1 JSON Schema",
+        description: "Complete JSON schema for SpecVerse v3.1 specifications",
+        mimeType: "application/json"
+      },
+      {
+        uri: "specverse://schema/ai-yaml",
+        name: "SpecVerse v3.1 AI-Optimized Schema",
+        description: "AI-friendly YAML schema with guidance and examples",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://prompts/create",
+        name: "Create Prompt Template",
+        description: "Template for generating SpecVerse specifications from requirements",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://prompts/analyse",
+        name: "Analysis Prompt Template",
+        description: "Template for extracting specifications from existing code",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://prompts/materialise",
+        name: "Implementation Planning Template",
+        description: "Template for creating implementation plans from specifications",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://prompts/realize",
+        name: "Code Generation Template",
+        description: "Template for generating source code from specifications",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://libraries/catalog",
+        name: "SpecVerse Library Catalog",
+        description: "Complete catalog of available SpecVerse libraries with AI metadata",
+        mimeType: "application/x-yaml"
+      },
+      {
+        uri: "specverse://examples/chat-prompts",
+        name: "Chat Prompt Examples",
+        description: "Example prompts for terminal/chat-based AI interactions",
+        mimeType: "text/markdown"
+      },
+      {
+        uri: "specverse://examples/api-calls",
+        name: "API Integration Examples",
+        description: "Examples for API-based AI integrations",
+        mimeType: "application/javascript"
+      }
+    ];
+    for (const resourceData of resources) {
+      const resource = SpecVerseResourceModel.create(resourceData);
+      this.resourceCatalog.set(resource.uri, resource);
+    }
+    this.isInitialized = true;
+  }
+  async listResources() {
+    await this.initializeResources();
+    return Array.from(this.resourceCatalog.values()).map((resource) => ({
+      uri: resource.uri,
+      name: resource.name,
+      description: resource.description,
+      mimeType: resource.mimeType,
+      content: resource.content,
+      metadata: resource.metadata
+    }));
+  }
+  async getResourceContent(uri) {
+    await this.initializeResources();
+    const resource = this.resourceCatalog.get(uri);
+    if (!resource) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+    if (resource.isLoaded()) {
+      return resource.content;
+    }
+    const resourcePath = this.resolveResourcePath(uri);
+    const embeddedResource = this.embeddedResources[resourcePath];
+    if (!embeddedResource) {
+      throw new Error(`Embedded resource not found: ${resourcePath} for URI: ${uri}`);
+    }
+    const updatedResource = resource.withContent(embeddedResource.content);
+    this.resourceCatalog.set(uri, updatedResource);
+    return embeddedResource.content;
+  }
+  async readResource(uri) {
+    try {
+      const content = await this.getResourceContent(uri);
+      const resource = this.resourceCatalog.get(uri);
+      return {
+        content: [{
+          type: "resource",
+          resource: {
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType,
+            content
+          }
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error reading resource: ${error instanceof Error ? error.message : String(error)}`
+        }],
+        isError: true
+      };
+    }
+  }
+  resolveResourcePath(uri) {
+    switch (uri) {
+      case "specverse://schema/json":
+        return "schemas/SPECVERSE-SCHEMA.json";
+      case "specverse://schema/ai-yaml":
+        return "schemas/specverse-ai.yaml";
+      case "specverse://prompts/create":
+        return "prompts/create.prompt.yaml";
+      case "specverse://prompts/analyse":
+        return "prompts/analyse.prompt.yaml";
+      case "specverse://prompts/materialise":
+        return "prompts/materialise.prompt.yaml";
+      case "specverse://prompts/realize":
+        return "prompts/realize.prompt.yaml";
+      case "specverse://libraries/catalog":
+        return "libraries/catalog/library-catalog.yaml";
+      case "specverse://examples/chat-prompts":
+        return "examples/chat-prompts/ecommerce-store-example.md";
+      case "specverse://examples/api-calls":
+        return "examples/api-calls/orchestrator-workflow-example.js";
+      default:
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+  }
+  isResourceAvailable(uri) {
+    return this.resourceCatalog.has(uri);
+  }
+  getCachedResourceCount() {
+    return Array.from(this.resourceCatalog.values()).filter((r) => r.isLoaded()).length;
+  }
+  getEmbeddedResourcesInfo() {
+    const paths = Object.keys(this.embeddedResources);
+    const totalSize = Object.values(this.embeddedResources).reduce((sum, res) => sum + res.size, 0);
+    return {
+      count: paths.length,
+      totalSize,
+      paths
+    };
+  }
+}
+export {
+  EmbeddedResourcesAdapter
+};

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

@@ -0,0 +1,240 @@
+class EntityModuleService {
+  registry = null;
+  behaviouralProcessor = null;
+  loaded = false;
+  /**
+   * Attempt to load the entity registry from @specverse/engine-entities.
+   * Fails gracefully if not available.
+   */
+  async initialize() {
+    try {
+      const { resolve, dirname } = await import("path");
+      const { fileURLToPath } = await import("url");
+      const baseDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+      const entitiesPath = resolve(baseDir, "dist", "entities", "index.js");
+      const conventionPath = resolve(baseDir, "dist", "entities", "_shared", "behaviour", "convention-processor.js");
+      const entitiesModule = await import(entitiesPath);
+      entitiesModule.bootstrapEntityModules();
+      this.registry = entitiesModule.getEntityRegistry();
+      const { BehaviouralConventionProcessor } = await import(conventionPath);
+      this.behaviouralProcessor = new BehaviouralConventionProcessor();
+      const entitiesDir = resolve(baseDir, "src", "entities");
+      this.behaviouralProcessor.loadGrammarsFromEntities(entitiesDir);
+      this.loaded = true;
+      return true;
+    } catch (error) {
+      this.loaded = false;
+      return false;
+    }
+  }
+  isAvailable() {
+    return this.loaded;
+  }
+  /**
+   * Get entity module metadata for all registered modules.
+   */
+  getEntityModules() {
+    if (!this.registry) return [];
+    const modules = this.registry.getInDependencyOrder();
+    return modules.map((mod) => ({
+      name: mod.name,
+      type: mod.type,
+      version: mod.version,
+      dependsOn: mod.dependsOn || [],
+      hasConventionProcessor: !!mod.conventionProcessor,
+      inferenceRuleCount: mod.inferenceRules?.length || 0,
+      inferenceRules: (mod.inferenceRules || []).map((r) => ({
+        id: r.id,
+        description: r.description,
+        triggeredBy: r.triggeredBy,
+        generates: r.generates
+      })),
+      diagramPlugins: mod.diagramPlugins || [],
+      generatorCount: mod.generators?.length || 0
+    }));
+  }
+  /**
+   * Get behavioural convention grammars for all entities.
+   */
+  getConventionGrammars() {
+    if (!this.behaviouralProcessor) return [];
+    return this.behaviouralProcessor.getGrammars().map((g) => ({
+      entity: g.entity,
+      domain: g.domain,
+      conventions: Object.values(g.conventions).map((c) => ({
+        name: c.name,
+        pattern: c.pattern,
+        description: c.description,
+        expandsTo: c.expandsTo
+      }))
+    }));
+  }
+  /**
+   * Expand a behavioural constraint string.
+   */
+  expandConstraint(input) {
+    if (!this.behaviouralProcessor) {
+      return { success: false, error: "Behavioural convention processor not available" };
+    }
+    const result = this.behaviouralProcessor.expand(input);
+    if (result) {
+      return { success: true, result };
+    }
+    return { success: false, error: `No matching convention pattern for: "${input}"` };
+  }
+  /**
+   * Generate MCP resources from entity module metadata.
+   */
+  generateResources() {
+    if (!this.loaded) return [];
+    const resources = [];
+    const modules = this.getEntityModules();
+    resources.push({
+      uri: "specverse://entities/registry",
+      name: "Entity Module Registry",
+      description: `All ${modules.length} registered entity modules with their facets, dependencies, and capabilities`,
+      mimeType: "application/json",
+      content: JSON.stringify({ entityModules: modules }, null, 2)
+    });
+    const grammars = this.getConventionGrammars();
+    const totalConventions = grammars.reduce((sum, g) => sum + g.conventions.length, 0);
+    resources.push({
+      uri: "specverse://entities/conventions",
+      name: "Behavioural Conventions Catalog",
+      description: `${totalConventions} behavioural conventions across ${grammars.length} entities. Use in constraints: section of .specly files.`,
+      mimeType: "application/json",
+      content: JSON.stringify({ grammars }, null, 2)
+    });
+    const allRules = modules.flatMap((m) => m.inferenceRules);
+    resources.push({
+      uri: "specverse://entities/inference-rules",
+      name: "Inference Rules Summary",
+      description: `${allRules.length} inference rules that generate architecture from specifications`,
+      mimeType: "application/json",
+      content: JSON.stringify({ rules: allRules }, null, 2)
+    });
+    const allPlugins = modules.flatMap(
+      (m) => m.diagramPlugins.map((p) => ({ ...p, entity: m.name }))
+    );
+    resources.push({
+      uri: "specverse://entities/diagram-plugins",
+      name: "Diagram Plugins",
+      description: `${allPlugins.length} diagram types available for visualization`,
+      mimeType: "application/json",
+      content: JSON.stringify({ plugins: allPlugins }, null, 2)
+    });
+    return resources;
+  }
+  /**
+   * Generate MCP tools for entity module interaction.
+   */
+  generateTools() {
+    if (!this.loaded) return [];
+    return [
+      {
+        name: "specverse_expand_constraint",
+        description: 'Expand a behavioural constraint string into a Quint invariant. Example: "models must have attributes"',
+        inputSchema: {
+          type: "object",
+          properties: {
+            constraint: {
+              type: "string",
+              description: 'Human-readable constraint to expand (e.g., "models must have attributes")'
+            }
+          },
+          required: ["constraint"]
+        }
+      },
+      {
+        name: "specverse_list_conventions",
+        description: "List available behavioural conventions for a specific entity type",
+        inputSchema: {
+          type: "object",
+          properties: {
+            entity: {
+              type: "string",
+              description: 'Entity type (e.g., "models", "controllers", "services")'
+            }
+          },
+          required: ["entity"]
+        }
+      },
+      {
+        name: "specverse_entity_info",
+        description: "Get detailed metadata about an entity module (conventions, inference rules, diagram plugins)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            entity: {
+              type: "string",
+              description: 'Entity name (e.g., "models", "controllers", "deployments")'
+            }
+          },
+          required: ["entity"]
+        }
+      }
+    ];
+  }
+  /**
+   * Execute an entity module tool.
+   */
+  async executeTool(name, args) {
+    switch (name) {
+      case "specverse_expand_constraint": {
+        const result = this.expandConstraint(args.constraint);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+      case "specverse_list_conventions": {
+        const grammars = this.getConventionGrammars();
+        const grammar = grammars.find((g) => g.entity === args.entity);
+        if (!grammar) {
+          return {
+            content: [{
+              type: "text",
+              text: `No conventions found for entity "${args.entity}". Available: ${grammars.map((g) => g.entity).join(", ")}`
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(grammar, null, 2)
+          }]
+        };
+      }
+      case "specverse_entity_info": {
+        const modules = this.getEntityModules();
+        const mod = modules.find((m) => m.name === args.entity);
+        if (!mod) {
+          return {
+            content: [{
+              type: "text",
+              text: `Entity "${args.entity}" not found. Available: ${modules.map((m) => m.name).join(", ")}`
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(mod, null, 2)
+          }]
+        };
+      }
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown entity module tool: ${name}`
+          }]
+        };
+    }
+  }
+}
+export {
+  EntityModuleService
+};

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

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { ResourcesProviderService } from "./ResourcesProviderService.js";
+import { EmbeddedResourcesAdapter } from "./EmbeddedResourcesAdapter.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+class HybridResourcesProvider {
+  provider;
+  mode;
+  constructor(config) {
+    this.mode = this.detectMode(config);
+    if (this.mode === "embedded") {
+      if (!config.embeddedResources) {
+        this.provider = new EmbeddedResourcesAdapter({});
+      } else {
+        this.provider = new EmbeddedResourcesAdapter(config.embeddedResources);
+      }
+    } else {
+      this.provider = new ResourcesProviderService(config.resourcesPath);
+    }
+  }
+  detectMode(config) {
+    if (config.mode === "filesystem") return "filesystem";
+    if (config.mode === "embedded") return "embedded";
+    if (config.embeddedResources) {
+      return "embedded";
+    }
+    if (this.hasEmbeddedResourcesFile()) {
+      return "embedded";
+    }
+    if (this.isWebEnvironment()) {
+      return "embedded";
+    }
+    const resourcesPath = config.resourcesPath || join(__dirname, "../../resources");
+    if (existsSync(resourcesPath)) {
+      return "filesystem";
+    }
+    if (this.tryImportEmbeddedResources()) {
+      return "embedded";
+    }
+    return "filesystem";
+  }
+  hasEmbeddedResourcesFile() {
+    try {
+      const embeddedPath2 = join(dirname(__dirname), "embedded-resources.js");
+      return existsSync(embeddedPath2);
+    } catch {
+      return false;
+    }
+  }
+  isWebEnvironment() {
+    try {
+      if (typeof window !== "undefined") return true;
+      return this.hasEmbeddedResourcesFile();
+    } catch {
+      return false;
+    }
+  }
+  loadEmbeddedResources() {
+    try {
+      const embeddedPath = join(dirname(__dirname), "embedded-resources.js");
+      if (existsSync(embeddedPath)) {
+        const content = readFileSync(embeddedPath, "utf-8");
+        const match = content.match(/export const EMBEDDED_RESOURCES = ({[\s\S]*?});/);
+        if (match) {
+          const embeddedResources = eval("(" + match[1] + ")");
+          return embeddedResources;
+        }
+      }
+      return null;
+    } catch (error) {
+      console.warn("Failed to load embedded resources:", error);
+      return null;
+    }
+  }
+  async loadEmbeddedResourcesAsync() {
+    try {
+      const embeddedPath2 = join(dirname(__dirname), "embedded-resources.js");
+      if (existsSync(embeddedPath2)) {
+        const embeddedModule = await import(embeddedPath2);
+        return embeddedModule.EMBEDDED_RESOURCES || null;
+      }
+      return null;
+    } catch (error) {
+      console.warn("Dynamic import of embedded resources failed:", error);
+      return null;
+    }
+  }
+  tryImportEmbeddedResources() {
+    return this.loadEmbeddedResources();
+  }
+  async initializeResources() {
+    if (this.mode === "embedded" && this.provider instanceof EmbeddedResourcesAdapter) {
+      const providerInfo = this.provider.getEmbeddedResourcesInfo();
+      if (providerInfo.count === 0) {
+        try {
+          const embeddedResources2 = await this.loadEmbeddedResourcesAsync();
+          if (embeddedResources2) {
+            this.provider = new EmbeddedResourcesAdapter(embeddedResources2);
+          }
+        } catch (error) {
+          console.warn("Failed to load embedded resources, falling back to filesystem:", error);
+          this.mode = "filesystem";
+          this.provider = new ResourcesProviderService();
+        }
+      }
+    }
+    return this.provider.initializeResources();
+  }
+  async listResources() {
+    return this.provider.listResources();
+  }
+  async getResourceContent(uri) {
+    return this.provider.getResourceContent(uri);
+  }
+  async readResource(uri) {
+    return this.provider.readResource(uri);
+  }
+  isResourceAvailable(uri) {
+    return this.provider.isResourceAvailable(uri);
+  }
+  getCachedResourceCount() {
+    return this.provider.getCachedResourceCount();
+  }
+  getMode() {
+    return this.mode;
+  }
+  getProviderInfo() {
+    const info = {
+      mode: this.mode,
+      type: this.provider.constructor.name,
+      resourcesInfo: void 0
+    };
+    if (this.provider instanceof EmbeddedResourcesAdapter) {
+      info.resourcesInfo = this.provider.getEmbeddedResourcesInfo();
+    } else if (this.provider instanceof ResourcesProviderService) {
+      info.resourcesInfo = {
+        cached: this.provider.getCachedResourceCount()
+      };
+    }
+    return info;
+  }
+}
+export {
+  HybridResourcesProvider
+};