@specverse/engines 4.1.13 → 4.1.15

package/dist/libs/instance-factories/tools/templates/mcp/static/src/controllers/MCPServerController.js

@@ -1,232 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { HybridResourcesProvider } from "../services/HybridResourcesProvider.js";
-import { CLIProxyService } from "../services/CLIProxyService.js";
-import { EntityModuleService } from "../services/EntityModuleService.js";
-import { EventEmitter } from "../events/EventEmitter.js";
-class MCPServerController {
-  server;
-  config;
-  resourcesProvider;
-  cliProxy;
-  entityModuleService;
-  eventEmitter;
-  constructor(config) {
-    this.config = config;
-    this.eventEmitter = new EventEmitter();
-    this.server = new Server({
-      name: "specverse-dynamic-cli",
-      version: "1.0.0"
-    }, {
-      capabilities: {
-        resources: {},
-        tools: {}
-      }
-    });
-    this.resourcesProvider = new HybridResourcesProvider({
-      mode: "auto",
-      resourcesPath: config.resources_path
-    });
-    this.cliProxy = new CLIProxyService();
-    this.entityModuleService = new EntityModuleService();
-    this.setupHandlers();
-  }
-  async listResources() {
-    try {
-      const startTime = Date.now();
-      const resources = await this.resourcesProvider.listResources();
-      if (this.entityModuleService.isAvailable()) {
-        resources.push(...this.entityModuleService.generateResources());
-      }
-      this.eventEmitter.emit("resource-requested", {
-        uri: "LIST_ALL",
-        requestTime: /* @__PURE__ */ new Date()
-      });
-      if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-        console.error(`Listed ${resources.length} resources in ${Date.now() - startTime}ms`);
-      }
-      return resources;
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "listResources",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  async readResource(uri) {
-    try {
-      const startTime = Date.now();
-      if (uri.startsWith("specverse://entities/") && this.entityModuleService.isAvailable()) {
-        const entityResources = this.entityModuleService.generateResources();
-        const resource2 = entityResources.find((r) => r.uri === uri);
-        if (resource2) {
-          this.eventEmitter.emit("resource-requested", { uri, requestTime: /* @__PURE__ */ new Date() });
-          return resource2;
-        }
-      }
-      const content = await this.resourcesProvider.getResourceContent(uri);
-      const resources = await this.resourcesProvider.listResources();
-      const resource = resources.find((r) => r.uri === uri);
-      if (!resource) {
-        throw new Error(`Resource not found: ${uri}`);
-      }
-      this.eventEmitter.emit("resource-requested", {
-        uri,
-        requestTime: /* @__PURE__ */ new Date()
-      });
-      if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-        console.error(`Read resource ${uri} in ${Date.now() - startTime}ms`);
-      }
-      return {
-        ...resource,
-        content
-      };
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "readResource",
-        error: error instanceof Error ? error.message : String(error),
-        context: { uri }
-      });
-      throw error;
-    }
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      const resources = await this.listResources();
-      return { resources };
-    });
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const resource = await this.readResource(request.params.uri);
-      return {
-        contents: [{
-          uri: resource.uri,
-          mimeType: resource.mimeType,
-          text: resource.content
-        }]
-      };
-    });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      let dynamicCliTools = [];
-      try {
-        dynamicCliTools = await this.cliProxy.generateMCPTools();
-        if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-          console.error(`\u{1F527} Generated ${dynamicCliTools.length} dynamic CLI tools`);
-        }
-      } catch (error) {
-        if (this.config.logging && process.env.MCP_DEBUG) {
-          console.error("\u26A0\uFE0F Failed to generate dynamic CLI tools:", error);
-        }
-      }
-      if (this.entityModuleService.isAvailable()) {
-        dynamicCliTools.push(...this.entityModuleService.generateTools());
-      }
-      return { tools: dynamicCliTools };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params;
-        const entityToolNames = ["specverse_expand_constraint", "specverse_list_conventions", "specverse_entity_info"];
-        if (entityToolNames.includes(name) && this.entityModuleService.isAvailable()) {
-          return await this.entityModuleService.executeTool(name, args || {});
-        }
-        if (name.startsWith("specverse_")) {
-          const result = await this.cliProxy.executeCommand(name, args || {});
-          return { content: result.content };
-        } else {
-          return {
-            content: [{
-              type: "text",
-              text: `Error: Unknown tool '${name}'. Only dynamic CLI tools (prefixed with 'specverse_') are supported.`
-            }]
-          };
-        }
-      } catch (error) {
-        return {
-          content: [{
-            type: "text",
-            text: `Error in tool handler: ${error instanceof Error ? error.message : String(error)}`
-          }]
-        };
-      }
-    });
-  }
-  /**
-   * Start the MCP server
-   */
-  async start() {
-    try {
-      await this.resourcesProvider.initializeResources();
-      const entityAvailable = await this.entityModuleService.initialize();
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        if (entityAvailable) {
-          const modules = this.entityModuleService.getEntityModules();
-          console.error(`\u{1F9E9} Entity modules loaded: ${modules.length} modules, ${modules.reduce((s, m) => s + m.inferenceRuleCount, 0)} rules`);
-        } else {
-          console.error("\u26A0\uFE0F Entity modules not available in this deployment");
-        }
-      }
-      this.eventEmitter.emit("server-started", {
-        serverName: "SpecVerse Dynamic CLI",
-        mode: this.config.mode,
-        timestamp: /* @__PURE__ */ new Date(),
-        featuresEnabled: this.config.features,
-        pid: process.pid
-      });
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        const mode = this.config.mode || "local";
-        const resourceCount = this.resourcesProvider.getCachedResourceCount();
-        console.error(`\u{1F680} SpecVerse MCP Server started in ${mode} mode`);
-        console.error(`\u{1F4DA} Loaded ${resourceCount} resources`);
-        console.error(`\u{1F527} Dynamic CLI integration enabled - all tools from CLI`);
-      }
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "start",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  /**
-   * Stop the MCP server
-   */
-  async stop() {
-    try {
-      await this.server.close();
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        console.error("\u{1F6D1} SpecVerse MCP Server stopped");
-      }
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "stop",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  // Methods expected by the main server
-  getEventEmitter() {
-    return this.eventEmitter;
-  }
-  async initialize() {
-    await this.start();
-  }
-  getServer() {
-    return this.server;
-  }
-  getMetrics() {
-    return {
-      resourceCount: this.resourcesProvider.getCachedResourceCount(),
-      cliIntegration: true
-    };
-  }
-}
-export {
-  MCPServerController
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/events/EventEmitter.js

@@ -1,49 +0,0 @@
-class EventEmitter {
-  listeners = /* @__PURE__ */ new Map();
-  on(eventType, handler) {
-    if (!this.listeners.has(eventType)) {
-      this.listeners.set(eventType, []);
-    }
-    this.listeners.get(eventType).push(handler);
-  }
-  off(eventType, handler) {
-    const handlers = this.listeners.get(eventType);
-    if (handlers) {
-      const index = handlers.indexOf(handler);
-      if (index !== -1) {
-        handlers.splice(index, 1);
-      }
-    }
-  }
-  async emit(eventType, data) {
-    const handlers = this.listeners.get(eventType);
-    if (handlers) {
-      const promises = handlers.map((handler) => {
-        try {
-          const result = handler(data);
-          return Promise.resolve(result);
-        } catch (error) {
-          console.error(`Error in event handler for ${eventType}:`, error);
-          return Promise.resolve();
-        }
-      });
-      await Promise.allSettled(promises);
-    }
-  }
-  removeAllListeners(eventType) {
-    if (eventType) {
-      this.listeners.delete(eventType);
-    } else {
-      this.listeners.clear();
-    }
-  }
-  listenerCount(eventType) {
-    return this.listeners.get(eventType)?.length || 0;
-  }
-  eventNames() {
-    return Array.from(this.listeners.keys());
-  }
-}
-export {
-  EventEmitter
-};

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

@@ -1,18 +0,0 @@
-import { SpecVerseCleanMCPServer } from "./server/mcp-server.js";
-import { MCPServerController } from "./controllers/MCPServerController.js";
-import { ResourcesProviderService } from "./services/ResourcesProviderService.js";
-import { LibraryToolsService } from "./services/LibraryToolsService.js";
-import { PromptToolsService } from "./services/PromptToolsService.js";
-import { SpecVerseResourceModel } from "./models/SpecVerseResource.js";
-import { LibrarySuggestionModel } from "./models/LibrarySuggestion.js";
-import { EventEmitter } from "./events/EventEmitter.js";
-export {
-  EventEmitter,
-  LibrarySuggestionModel,
-  LibraryToolsService,
-  MCPServerController,
-  PromptToolsService,
-  ResourcesProviderService,
-  SpecVerseCleanMCPServer,
-  SpecVerseResourceModel
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/models/LibrarySuggestion.js

@@ -1,97 +0,0 @@
-import { z } from "zod";
-const LibrarySuggestionSchema = z.object({
-  name: z.string().min(1, "Name is required"),
-  path: z.string().min(1, "Path is required"),
-  type: z.enum(["deployment", "domain", "manifest", "type", "standard"]),
-  description: z.string().min(1, "Description is required"),
-  ai_description: z.string().min(1, "AI description is required"),
-  expansion_factor: z.number().min(1, "Expansion factor must be >= 1"),
-  complexity_level: z.enum(["low", "medium", "high"]),
-  best_for: z.array(z.string()).min(1, "Must specify at least one use case")
-});
-class LibrarySuggestionModel {
-  constructor(name, path, type, description, ai_description, expansion_factor, complexity_level, best_for) {
-    this.name = name;
-    this.path = path;
-    this.type = type;
-    this.description = description;
-    this.ai_description = ai_description;
-    this.expansion_factor = expansion_factor;
-    this.complexity_level = complexity_level;
-    this.best_for = best_for;
-  }
-  static create(data) {
-    const validated = LibrarySuggestionSchema.parse(data);
-    return new LibrarySuggestionModel(
-      validated.name,
-      validated.path,
-      validated.type,
-      validated.description,
-      validated.ai_description,
-      validated.expansion_factor,
-      validated.complexity_level,
-      validated.best_for
-    );
-  }
-  static fromJson(json) {
-    const data = JSON.parse(json);
-    return this.create(data);
-  }
-  toJson() {
-    return JSON.stringify({
-      name: this.name,
-      path: this.path,
-      type: this.type,
-      description: this.description,
-      ai_description: this.ai_description,
-      expansion_factor: this.expansion_factor,
-      complexity_level: this.complexity_level,
-      best_for: this.best_for
-    });
-  }
-  matchesContext(context, scale) {
-    let score = 0;
-    const contextLower = context.toLowerCase();
-    for (const useCase of this.best_for) {
-      if (contextLower.includes(useCase.toLowerCase())) {
-        score += 2;
-      }
-    }
-    const scaleComplexity = this.getScaleComplexity(scale);
-    const complexityScore = this.getComplexityScore();
-    const complexityMatch = Math.abs(complexityScore - scaleComplexity);
-    score += Math.max(0, 3 - complexityMatch);
-    return score;
-  }
-  getScaleComplexity(scale) {
-    switch (scale) {
-      case "personal":
-        return 1;
-      case "business":
-        return 2;
-      case "enterprise":
-        return 3;
-      default:
-        return 2;
-    }
-  }
-  getComplexityScore() {
-    switch (this.complexity_level) {
-      case "low":
-        return 1;
-      case "medium":
-        return 2;
-      case "high":
-        return 3;
-      default:
-        return 2;
-    }
-  }
-  getRelevanceScore() {
-    return this.expansion_factor * this.getComplexityScore();
-  }
-}
-export {
-  LibrarySuggestionModel,
-  LibrarySuggestionSchema
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/models/SpecVerseResource.js

@@ -1,64 +0,0 @@
-import { z } from "zod";
-const SpecVerseResourceSchema = z.object({
-  uri: z.string().min(1, "URI is required").regex(/^specverse:\/\//, "URI must start with specverse://"),
-  name: z.string().min(1, "Name is required"),
-  description: z.string().min(1, "Description is required"),
-  mimeType: z.string().min(1, "MIME type is required"),
-  content: z.string().optional(),
-  metadata: z.record(z.any()).optional()
-});
-class SpecVerseResourceModel {
-  constructor(uri, name, description, mimeType, content, metadata) {
-    this.uri = uri;
-    this.name = name;
-    this.description = description;
-    this.mimeType = mimeType;
-    this.content = content;
-    this.metadata = metadata;
-  }
-  static create(data) {
-    const validated = SpecVerseResourceSchema.parse(data);
-    return new SpecVerseResourceModel(
-      validated.uri,
-      validated.name,
-      validated.description,
-      validated.mimeType,
-      validated.content,
-      validated.metadata
-    );
-  }
-  static fromJson(json) {
-    const data = JSON.parse(json);
-    return this.create(data);
-  }
-  toJson() {
-    return JSON.stringify({
-      uri: this.uri,
-      name: this.name,
-      description: this.description,
-      mimeType: this.mimeType,
-      content: this.content,
-      metadata: this.metadata
-    });
-  }
-  withContent(content) {
-    return new SpecVerseResourceModel(
-      this.uri,
-      this.name,
-      this.description,
-      this.mimeType,
-      content,
-      this.metadata
-    );
-  }
-  matches(uri) {
-    return this.uri === uri;
-  }
-  isLoaded() {
-    return this.content !== void 0;
-  }
-}
-export {
-  SpecVerseResourceModel,
-  SpecVerseResourceSchema
-};

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

@@ -1,182 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { MCPServerController } from "../controllers/MCPServerController.js";
-class SpecVerseCleanMCPServer {
-  controller;
-  config;
-  constructor(config) {
-    this.config = config;
-    this.controller = new MCPServerController(config);
-    this.setupEventHandlers();
-  }
-  setupEventHandlers() {
-    const eventEmitter = this.controller.getEventEmitter();
-    if (this.config.logging && this.config.mode !== "local") {
-      eventEmitter.on("server-started", (event) => {
-        const serverEvent = event;
-        console.error(`Clean MCP Server started in ${serverEvent.mode} mode (PID: ${serverEvent.pid})`);
-        if (serverEvent.port) {
-          console.error(`Server listening on port ${serverEvent.port}`);
-        }
-      });
-      eventEmitter.on("tool-called", (event) => {
-        const toolEvent = event;
-        console.error(`Tool executed: ${toolEvent.toolName} (${toolEvent.executionTime}ms)`);
-      });
-      eventEmitter.on("resource-requested", (event) => {
-        const resourceEvent = event;
-        console.error(`Resource accessed: ${resourceEvent.uri}`);
-      });
-      eventEmitter.on("error-occurred", (event) => {
-        const errorEvent = event;
-        console.error(`Error in ${errorEvent.operation}: ${errorEvent.error}`);
-        if (errorEvent.context) {
-          console.error("Context:", JSON.stringify(errorEvent.context, null, 2));
-        }
-      });
-    }
-  }
-  async start() {
-    await this.controller.initialize();
-    if (this.config.mode === "local") {
-      const transport = new StdioServerTransport(process.stdin, process.stdout);
-      try {
-        await this.controller.getServer().connect(transport);
-      } catch (error) {
-        console.error("MCP Server connection failed:", error);
-        process.exit(1);
-      }
-      const gracefulShutdown = () => {
-        process.exit(0);
-      };
-      process.on("SIGINT", gracefulShutdown);
-      process.on("SIGTERM", gracefulShutdown);
-      process.stdin.resume();
-    } else if (this.config.mode === "remote") {
-      if (this.config.logging) {
-        console.error("Starting Clean MCP Server in remote mode...");
-      }
-      const { createServer } = await import("http");
-      const server = createServer(async (req, res) => {
-        if (req.url === "/health") {
-          const metrics = this.controller.getMetrics();
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({
-            status: "healthy",
-            mode: "remote",
-            metrics
-          }));
-        } else if (req.url === "/mcp/resources") {
-          try {
-            const resources = await this.controller.listResources();
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-              resources,
-              count: resources.length,
-              mode: "remote"
-            }));
-          } catch (error) {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-              error: error instanceof Error ? error.message : String(error)
-            }));
-          }
-        } else if (req.url?.startsWith("/mcp/resource/")) {
-          try {
-            const uri = decodeURIComponent(req.url.replace("/mcp/resource/", ""));
-            const resource = await this.controller.readResource(uri);
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify(resource));
-          } catch (error) {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-              error: error instanceof Error ? error.message : String(error)
-            }));
-          }
-        } else if (req.url === "/mcp") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({
-            message: "MCP over HTTP partially implemented",
-            mode: "remote",
-            endpoints: [
-              "/mcp/resources - List all resources",
-              "/mcp/resource/{uri} - Read specific resource"
-            ]
-          }));
-        } else {
-          res.writeHead(404);
-          res.end("Not found");
-        }
-      });
-      const port = this.config.port || 3e3;
-      server.listen(port, () => {
-        if (this.config.logging) {
-          console.error(`Clean MCP Server listening on port ${port}`);
-          console.error("Health check: http://localhost:" + port + "/health");
-        }
-      });
-      const gracefulShutdown = () => {
-        if (this.config.logging) {
-          console.error("Clean MCP Server shutting down...");
-        }
-        server.close(() => {
-          process.exit(0);
-        });
-      };
-      process.on("SIGINT", gracefulShutdown);
-      process.on("SIGTERM", gracefulShutdown);
-    } else {
-      throw new Error(`Unsupported mode: ${this.config.mode}`);
-    }
-  }
-  getController() {
-    return this.controller;
-  }
-}
-async function main() {
-  process.on("uncaughtException", (error) => {
-    console.error("Uncaught exception in Clean MCP server:", error);
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (reason, promise) => {
-    console.error("Unhandled rejection in Clean MCP server:", reason);
-    process.exit(1);
-  });
-  const args = process.argv.slice(2);
-  const mode = args.includes("--mode") ? args[args.indexOf("--mode") + 1] : "local";
-  const port = args.includes("--port") ? parseInt(args[args.indexOf("--port") + 1]) : 3e3;
-  const config = {
-    mode,
-    port,
-    logging: !args.includes("--silent"),
-    resources_path: args.includes("--resources-path") ? args[args.indexOf("--resources-path") + 1] : void 0,
-    features: {
-      orchestrator: args.includes("--enable-orchestrator")
-    }
-  };
-  if (config.logging && config.mode !== "local") {
-    console.error("Starting Clean SpecVerse MCP Server with config:", JSON.stringify(config, null, 2));
-  }
-  try {
-    const server = new SpecVerseCleanMCPServer(config);
-    await server.start();
-  } catch (error) {
-    console.error("Failed to start Clean MCP Server:", error);
-    process.exit(1);
-  }
-}
-const condition1 = import.meta.url === `file://${process.argv[1]}`;
-const condition2 = process.argv[1]?.includes("mcp-server.js");
-const condition3 = process.argv[0]?.includes("specverse-mcp");
-const condition4 = process.argv[1]?.includes("specverse-mcp");
-const isMainModule = condition1 || condition2 || condition3 || condition4;
-if (isMainModule) {
-  main().catch((error) => {
-    console.error("Fatal error in Clean MCP Server:", error);
-    process.exit(1);
-  });
-}
-export {
-  SpecVerseCleanMCPServer,
-  main
-};