@specverse/engines 4.1.5 → 4.1.7

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

@@ -0,0 +1,467 @@
+import { enhancePrompt } from "@specverse/engine-ai";
+class PromptToolsService {
+  resourcesProvider;
+  libraryTools;
+  constructor(resourcesProvider, libraryTools) {
+    this.resourcesProvider = resourcesProvider;
+    this.libraryTools = libraryTools;
+  }
+  async getCreationPrompt(context) {
+    try {
+      const sanitizedContext = this.sanitizeContext(context);
+      const result = await this.callAICommand("enhance", "create", {
+        requirements: sanitizedContext.requirements || "",
+        scale: this.mapScale(sanitizedContext.scale),
+        framework: sanitizedContext.preferredTech,
+        technology_preferences: sanitizedContext.preferredTech ? [sanitizedContext.preferredTech] : void 0
+      });
+      const expandedPrompt = {
+        system_prompt: result.systemPrompt,
+        user_prompt: result.userPrompt,
+        context: result.contextPrompt,
+        libraries: result.libraryContext?.suggestions?.slice(0, 5) || [],
+        estimated_tokens: result.estimatedTokens,
+        execution_options: result.executionOptions
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(expandedPrompt, null, 2)
+        }]
+      };
+    } catch (error) {
+      return this.createErrorResult("getCreationPrompt", error);
+    }
+  }
+  async getAnalysisPrompt(context) {
+    try {
+      const sanitizedContext = this.sanitizeContext(context);
+      const result = await this.callAICommand("enhance", "analyse", {
+        requirements: sanitizedContext.projectType || "code analysis",
+        framework: sanitizedContext.frameworkHint
+      });
+      const expandedPrompt = {
+        system_prompt: result.systemPrompt,
+        user_prompt: result.userPrompt,
+        context: result.contextPrompt,
+        estimated_tokens: result.estimatedTokens,
+        execution_options: result.executionOptions
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(expandedPrompt, null, 2)
+        }]
+      };
+    } catch (error) {
+      return this.createErrorResult("getAnalysisPrompt", error);
+    }
+  }
+  async getImplementationPrompt(context) {
+    try {
+      const sanitizedContext = this.sanitizeContext(context);
+      const result = await this.callAICommand("enhance", "materialise", {
+        requirements: `implementation planning for ${sanitizedContext.targetFramework || "specified framework"}`,
+        framework: sanitizedContext.targetFramework,
+        technology_preferences: sanitizedContext.deploymentType ? [sanitizedContext.deploymentType] : void 0
+      });
+      const expandedPrompt = {
+        system_prompt: result.systemPrompt,
+        user_prompt: result.userPrompt,
+        context: result.contextPrompt,
+        estimated_tokens: result.estimatedTokens,
+        execution_options: result.executionOptions
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(expandedPrompt, null, 2)
+        }]
+      };
+    } catch (error) {
+      return this.createErrorResult("getImplementationPrompt", error);
+    }
+  }
+  async getRealizationPrompt(context) {
+    try {
+      const sanitizedContext = this.sanitizeContext(context);
+      const result = await this.callAICommand("enhance", "realize", {
+        requirements: `code generation for ${sanitizedContext.targetFramework || "specified framework"}`,
+        framework: sanitizedContext.targetFramework,
+        scale: this.mapScale(sanitizedContext.implementationScope)
+      });
+      const expandedPrompt = {
+        system_prompt: result.systemPrompt,
+        user_prompt: result.userPrompt,
+        context: result.contextPrompt,
+        estimated_tokens: result.estimatedTokens,
+        execution_options: result.executionOptions
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(expandedPrompt, null, 2)
+        }]
+      };
+    } catch (error) {
+      return this.createErrorResult("getRealizationPrompt", error);
+    }
+  }
+  async getValidationInstructions(args) {
+    try {
+      const validationType = args.validationType || "syntax";
+      const instructions = this.generateValidationInstructions(validationType);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(instructions, null, 2)
+        }]
+      };
+    } catch (error) {
+      return this.createErrorResult("getValidationInstructions", error);
+    }
+  }
+  parseTemplate(template) {
+    return {
+      systemRole: template?.system?.role || template?.system_role || "",
+      systemContext: template?.system?.context || template?.system_context || "",
+      userTemplate: template?.user?.template || template?.user_template || ""
+    };
+  }
+  expandCreationPrompt(template, context) {
+    const { requirements, scale = "business", preferredTech = "auto", libraries = [], reasoning = "" } = context;
+    const { systemRole, systemContext, userTemplate } = this.parseTemplate(template);
+    let systemPrompt = systemRole + "\\n\\n" + systemContext;
+    systemPrompt += "\\n\\n" + this.getScaleGuidance(scale);
+    if (libraries.length > 0) {
+      systemPrompt += "\\n\\nLIBRARY CONTEXT:\\n";
+      systemPrompt += `Consider these relevant SpecVerse libraries: ${libraries.map((lib) => lib.name).join(", ")}\\n`;
+      systemPrompt += `Library selection reasoning: ${reasoning}`;
+    }
+    let userPrompt = "";
+    try {
+      if (userTemplate === null || userTemplate === void 0) {
+        userPrompt = "";
+      } else if (typeof userTemplate === "string") {
+        userPrompt = userTemplate;
+      } else {
+        userPrompt = String(userTemplate);
+      }
+      if (userPrompt && userPrompt.length > 0 && typeof userPrompt === "string") {
+        userPrompt = userPrompt.replace(/\\{\\{requirements\\}\\}/g, requirements || "Not specified");
+        userPrompt = userPrompt.replace(/\\{\\{scale\\}\\}/g, scale);
+        userPrompt = userPrompt.replace(/\\{\\{preferredTech\\}\\}/g, preferredTech);
+      }
+    } catch (error) {
+      userPrompt = "";
+    }
+    const constraints = template.system_constraints?.join("\\n- ") || "";
+    const contextSection = constraints ? `\\nCONSTRAINTS:\\n- ${constraints}` : "";
+    return {
+      system_prompt: systemPrompt,
+      user_prompt: userPrompt,
+      context: contextSection,
+      libraries: libraries.slice(0, 5)
+    };
+  }
+  expandAnalysisPrompt(template, context) {
+    const { projectType, frameworkHint } = context;
+    const { systemRole, systemContext, userTemplate } = this.parseTemplate(template);
+    let systemPrompt = systemRole + "\\n\\n" + systemContext;
+    if (projectType) {
+      systemPrompt += `\\n\\nPROJECT TYPE: ${projectType}`;
+      systemPrompt += this.getProjectTypeGuidance(projectType);
+    }
+    let userPrompt = userTemplate || "";
+    if (typeof userPrompt !== "string") {
+      userPrompt = "";
+    }
+    if (userPrompt && userPrompt.length > 0) {
+      try {
+        userPrompt = userPrompt.replace(/\\{\\{frameworkType\\}\\}/g, frameworkHint || "auto-detect");
+      } catch (error) {
+        console.warn("Error during analysis template replacement:", error);
+        userPrompt = `Template expansion failed: ${userTemplate}`;
+      }
+    }
+    const analysisInstructions = `
+ANALYSIS INSTRUCTIONS:
+1. Scan the following files for models, controllers, and services
+2. Identify relationships between data models
+3. Extract API endpoints and map to controller actions
+4. Detect business logic patterns and event flows
+5. Generate a clean SpecVerse specification
+
+Please provide the directory structure and key file contents for analysis.`;
+    return {
+      system_prompt: systemPrompt,
+      user_prompt: userPrompt,
+      context: analysisInstructions
+    };
+  }
+  expandImplementationPrompt(template, context) {
+    const { targetFramework, deploymentType } = context;
+    const { systemRole, systemContext, userTemplate } = this.parseTemplate(template);
+    let systemPrompt = systemRole + "\\n\\n" + systemContext;
+    systemPrompt += `\\n\\nTARGET FRAMEWORK: ${targetFramework}`;
+    if (deploymentType) {
+      systemPrompt += `\\nDEPLOYMENT TYPE: ${deploymentType}`;
+    }
+    let userPrompt = userTemplate || "";
+    if (typeof userPrompt !== "string") {
+      userPrompt = "";
+    }
+    if (userPrompt && userPrompt.length > 0) {
+      try {
+        userPrompt = userPrompt.replace(/\\{\\{targetFramework\\}\\}/g, targetFramework);
+      } catch (error) {
+        console.warn("Error during implementation template replacement:", error);
+        userPrompt = `Template expansion failed: ${userTemplate}`;
+      }
+    }
+    const implementationContext = `
+IMPLEMENTATION PLANNING FOCUS:
+1. Break down the specification into implementable modules
+2. Define file structure and component organization  
+3. Identify dependencies and integration points
+4. Create development workflow and build process
+5. Plan testing strategy and deployment pipeline
+
+Framework-specific patterns for ${targetFramework} will be prioritized.`;
+    return {
+      system_prompt: systemPrompt,
+      user_prompt: userPrompt,
+      context: implementationContext
+    };
+  }
+  expandRealizationPrompt(template, context) {
+    const { targetFramework, implementationScope = "full" } = context;
+    const { systemRole, systemContext, userTemplate } = this.parseTemplate(template);
+    let systemPrompt = systemRole + "\\n\\n" + systemContext;
+    systemPrompt += `\\n\\nTARGET FRAMEWORK: ${targetFramework}`;
+    systemPrompt += `\\nSCOPE: ${implementationScope}`;
+    let userPrompt = userTemplate || "";
+    if (typeof userPrompt !== "string") {
+      userPrompt = "";
+    }
+    if (userPrompt && userPrompt.length > 0) {
+      try {
+        userPrompt = userPrompt.replace(/\\{\\{targetFramework\\}\\}/g, targetFramework);
+      } catch (error) {
+        console.warn("Error during realization template replacement:", error);
+        userPrompt = `Template expansion failed: ${userTemplate}`;
+      }
+    }
+    const scopeGuidance = this.getScopeGuidance(implementationScope);
+    return {
+      system_prompt: systemPrompt,
+      user_prompt: userPrompt,
+      context: scopeGuidance
+    };
+  }
+  getScaleGuidance(scale) {
+    switch (scale) {
+      case "personal":
+        return `
+PERSONAL SCALE GUIDANCE:
+- Focus on simplicity and ease of use
+- Minimize dependencies and complexity
+- Single-user scenarios are acceptable
+- SQLite and local storage are preferred
+- Simple authentication patterns`;
+      case "enterprise":
+        return `
+ENTERPRISE SCALE GUIDANCE:
+- Multi-tenant architecture required
+- Comprehensive audit trails and logging
+- Role-based access control (RBAC)
+- High availability and scalability
+- Compliance considerations (SOX, GDPR, HIPAA)
+- Microservices patterns preferred`;
+      default:
+        return `
+BUSINESS SCALE GUIDANCE:
+- Multi-user support with role management
+- Professional authentication (OAuth)
+- Relational database (PostgreSQL preferred)
+- API-first architecture
+- Moderate scalability requirements`;
+    }
+  }
+  getProjectTypeGuidance(projectType) {
+    switch (projectType.toLowerCase()) {
+      case "web":
+        return "\\nFocus on: Controllers for pages, Services for business logic, Events for user interactions";
+      case "api":
+        return "\\nFocus on: RESTful endpoints, Data models, Service layers, Authentication";
+      case "mobile":
+        return "\\nFocus on: Screen controllers, Local storage, Sync patterns, Offline support";
+      default:
+        return "\\nUse general analysis patterns for all architectural components";
+    }
+  }
+  getScopeGuidance(scope) {
+    switch (scope) {
+      case "mvp":
+        return `
+MVP SCOPE:
+- Essential features only
+- Minimal error handling
+- Basic styling and UX
+- Skip advanced features
+- Focus on core user journey`;
+      case "prototype":
+        return `
+PROTOTYPE SCOPE:
+- Rapid development approach
+- Mock data acceptable
+- Basic functionality demonstration
+- Minimal production considerations`;
+      default:
+        return `
+FULL IMPLEMENTATION SCOPE:
+- Complete feature set
+- Production-ready code quality
+- Comprehensive error handling
+- Full testing coverage
+- Security best practices`;
+    }
+  }
+  generateValidationInstructions(validationType) {
+    switch (validationType) {
+      case "syntax":
+        return {
+          command: "specverse check specs/main.specly",
+          description: "Validate SpecVerse specification syntax",
+          expected_output: "Specification is valid",
+          common_issues: [
+            "Invalid YAML syntax",
+            "Missing required fields",
+            "Incorrect property names",
+            "Invalid relationship syntax"
+          ],
+          fix_suggestions: [
+            "Check YAML indentation (use spaces, not tabs)",
+            "Ensure all required fields are present",
+            "Verify property names match schema",
+            "Use correct relationship syntax: hasMany, belongsTo, etc."
+          ]
+        };
+      case "semantic":
+        return {
+          command: "specverse check specs/main.specly --semantic",
+          description: "Validate semantic consistency and relationships",
+          expected_output: "No semantic errors found",
+          common_issues: [
+            "Circular relationship dependencies",
+            "Missing relationship targets",
+            "Inconsistent naming conventions",
+            "Unreferenced models"
+          ],
+          fix_suggestions: [
+            "Check for circular references in relationships",
+            "Ensure all relationship targets exist",
+            "Use consistent PascalCase for models",
+            "Remove unused models or add references"
+          ]
+        };
+      default:
+        return {
+          command: "specverse check specs/main.specly",
+          description: "Basic specification validation",
+          expected_output: "Validation successful",
+          common_issues: ["Syntax errors", "Schema violations"],
+          fix_suggestions: ["Fix syntax errors", "Follow SpecVerse schema"]
+        };
+    }
+  }
+  mapScale(scale) {
+    switch (scale) {
+      case "personal":
+      case "mvp":
+      case "prototype":
+        return "personal";
+      case "enterprise":
+      case "full":
+        return "enterprise";
+      default:
+        return "business";
+    }
+  }
+  /**
+   * Call AI commands directly using src/ai/ API.
+   * This provides better integration and type safety than CLI calls.
+   */
+  async callAICommand(action, operation, params) {
+    try {
+      const requirements = {
+        requirements: params.requirements || "",
+        scale: params.scale || "business",
+        framework: params.framework,
+        technology_preferences: params.technology_preferences
+      };
+      if (action === "enhance") {
+        return await enhancePrompt(operation, requirements);
+      } else {
+        throw new Error(`Unsupported action: ${action}`);
+      }
+    } catch (error) {
+      console.warn("Direct API call failed, falling back to basic prompt:", error);
+      return {
+        systemPrompt: `You are a SpecVerse specification ${operation} expert.`,
+        userPrompt: `Please ${operation} a specification for: ${params.requirements}`,
+        contextPrompt: `Scale: ${params.scale || "business"}, Framework: ${params.framework || "auto"}`,
+        estimatedTokens: 1e3,
+        variables: [],
+        libraryContext: {
+          total: 0,
+          suggestions: [],
+          reasoning: "Basic fallback mode - no library suggestions available"
+        },
+        executionOptions: [
+          { provider: "interactive", description: "Interactive copy-paste (Free)", estimatedCost: 0 },
+          { provider: "openai", description: "OpenAI GPT-3.5 ($0.002)", estimatedCost: 2e-3 },
+          { provider: "openai", description: "OpenAI GPT-4 ($0.03)", estimatedCost: 0.03 }
+        ]
+      };
+    }
+  }
+  sanitizeContext(context) {
+    if (!context || typeof context !== "object") {
+      return { requirements: "", scale: "business", preferredTech: "auto" };
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(context)) {
+      if (value === null || value === void 0) {
+        sanitized[key] = "";
+      } else if (typeof value === "string") {
+        sanitized[key] = String(value).trim();
+      } else {
+        sanitized[key] = String(value).trim();
+      }
+    }
+    return {
+      requirements: sanitized.requirements || "",
+      scale: sanitized.scale || "business",
+      preferredTech: sanitized.preferredTech || "auto",
+      projectType: sanitized.projectType || "",
+      frameworkHint: sanitized.frameworkHint || "",
+      targetFramework: sanitized.targetFramework || "",
+      deploymentType: sanitized.deploymentType || "",
+      implementationScope: sanitized.implementationScope || "full",
+      ...sanitized
+    };
+  }
+  createErrorResult(operation, error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error in ${operation}: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+}
+export {
+  PromptToolsService
+};

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

@@ -0,0 +1,135 @@
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { SpecVerseResourceModel } from "../models/SpecVerseResource.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+class ResourcesProviderService {
+  resourceCatalog = /* @__PURE__ */ new Map();
+  resourcesPath;
+  isInitialized = false;
+  constructor(resourcesPath) {
+    if (resourcesPath) {
+      this.resourcesPath = resourcesPath;
+    } else {
+      const candidatePaths = [
+        join(__dirname, "../resources"),
+        // NPM package structure
+        join(__dirname, "../../resources")
+        // Development structure
+      ];
+      this.resourcesPath = candidatePaths[0];
+      try {
+        for (const path of candidatePaths) {
+          if (existsSync(path)) {
+            this.resourcesPath = path;
+            break;
+          }
+        }
+      } catch (error) {
+        this.resourcesPath = candidatePaths[0];
+      }
+    }
+  }
+  async initializeResources() {
+    if (this.isInitialized) {
+      return;
+    }
+    const resources = [
+      {
+        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 filePath = this.resolveResourcePath(uri);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const updatedResource = resource.withContent(content);
+      this.resourceCatalog.set(uri, updatedResource);
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to load resource ${uri}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  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) {
+      // Schemas and catalogs removed - now provided through AI tools
+      case "specverse://examples/chat-prompts":
+        return join(this.resourcesPath, "examples/chat-prompts/ecommerce-store-example.md");
+      case "specverse://examples/api-calls":
+        return join(this.resourcesPath, "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;
+  }
+}
+export {
+  ResourcesProviderService
+};