@specverse/engines 5.0.2 → 5.2.0

package/libs/instance-factories/tools/templates/mcp/mcp-server-generator.ts

@@ -12,8 +12,11 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+
+const require = createRequire(import.meta.url);
 
 export default function generateMCPServer(context: TemplateContext): string {
   const { spec, outputDir } = context;
@@ -23,7 +26,14 @@ export default function generateMCPServer(context: TemplateContext): string {
   if (!existsSync(srcDir)) mkdirSync(srcDir, { recursive: true });
 
   const distribution = extractMCPDistribution(spec);
-  const version = distribution?.version || spec?.metadata?.version || spec?.version || '5.0.0';
+  // Prefer @specverse/self's real version over the spec's stale component
+  // version label. Falls back to the spec + default.
+  const version =
+    distribution?.version ||
+    resolveSelfVersion() ||
+    spec?.metadata?.version ||
+    spec?.version ||
+    '5.1.0';
   const description = distribution?.description
     || 'SpecVerse MCP server — exposes the specverse CLI as MCP tools and the live spec schema + docs as MCP resources.';
   const displayName = distribution?.displayName || 'SpecVerse MCP';
@@ -34,10 +44,26 @@ export default function generateMCPServer(context: TemplateContext): string {
   writeFileSync(join(mcpDir, 'tsconfig.json'), generateTsconfig());
   writeFileSync(join(srcDir, 'server.ts'), generateServer(displayName, version));
   writeFileSync(join(srcDir, 'cli-runner.ts'), generateCliRunner());
-  writeFileSync(join(srcDir, 'resources.ts'), generateResources());
+  writeFileSync(join(srcDir, 'resources.ts'), generateResources(cliCommands));
   writeFileSync(join(srcDir, 'tools.ts'), generateTools(cliCommands));
+  writeFileSync(join(srcDir, 'prompts.ts'), generatePrompts());
+
+  return `MCP server generated in: ${mcpDir}\n  ${cliCommands.length} tools, 5 resources, 6 prompts (derived from @specverse/engines/assets/prompts)`;
+}
 
-  return `MCP server generated in: ${mcpDir}\n  ${cliCommands.length} tools (one per CLI command), 2 resources (schema + docs)`;
+/**
+ * Read the running @specverse/self install's version from its package.json so
+ * the MCP server reports a real version instead of a stale component label.
+ * Returns null if @specverse/self isn't resolvable (e.g. during in-repo tests).
+ */
+function resolveSelfVersion(): string | null {
+  try {
+    const pkgPath = require.resolve('@specverse/self/package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
 }
 
 // ─── spec extraction ───────────────────────────────────────────────────────
@@ -182,9 +208,13 @@ function generatePackageJson(version: string, description: string): string {
     },
     dependencies: {
       '@modelcontextprotocol/sdk': '^1.17.4',
-      '@specverse/entities': '^5.0.0',
+      '@specverse/engines': '^5.2.0',
+      '@specverse/entities': '^5.1.0',
+      '@specverse/self': '^5.2.0',
+      'js-yaml': '^4.1.0',
     },
     devDependencies: {
+      '@types/js-yaml': '^4.0.9',
       '@types/node': '^20.19.11',
       typescript: '^5.9.2',
     },
@@ -221,13 +251,15 @@ function generateTsconfig(): string {
 }
 
 function generateServer(displayName: string, version: string): string {
+  const instructions = SERVER_INSTRUCTIONS;
   return `#!/usr/bin/env node
 /**
  * SpecVerse MCP Server — stdio transport.
  *
- * Wires the MCP protocol to the generated tool registry + live resources.
- * No handwritten business logic — everything is derived from the spec
- * (tools from CLI commands) or from @specverse/entities (schema + docs).
+ * Wires the MCP protocol to the generated tool registry + live resources
+ * + canonical workflow prompts. Everything is derived from the spec
+ * (tools from CLI commands, resources from @specverse/entities + @specverse/self,
+ * prompts from @specverse/engines/assets/prompts/core/standard/default).
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -236,13 +268,21 @@ import {
   CallToolRequestSchema,
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { TOOLS, callTool } from './tools.js';
 import { RESOURCES, readResource } from './resources.js';
+import { PROMPTS, getPrompt } from './prompts.js';
+
+const INSTRUCTIONS = ${JSON.stringify(instructions)};
 
 const server = new Server(
   { name: ${JSON.stringify(displayName)}, version: ${JSON.stringify(version)} },
-  { capabilities: { tools: {}, resources: {} } },
+  {
+    capabilities: { tools: {}, resources: {}, prompts: {} },
+    instructions: INSTRUCTIONS,
+  },
 );
 
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -271,11 +311,52 @@ server.setRequestHandler(ReadResourceRequestSchema, async (req: { params: { uri:
   return readResource(req.params.uri);
 });
 
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+  prompts: PROMPTS.map(p => ({
+    name: p.name,
+    description: p.description,
+    arguments: p.arguments,
+  })),
+}));
+
+server.setRequestHandler(GetPromptRequestSchema, async (req: { params: { name: string; arguments?: Record<string, string> } }) => {
+  const { name, arguments: args } = req.params;
+  return getPrompt(name, args ?? {});
+});
+
 const transport = new StdioServerTransport();
 await server.connect(transport);
 `;
 }
 
+const SERVER_INSTRUCTIONS = [
+  'SpecVerse is a declarative specification language. You describe WHAT a system does in a .specly file, and the engines generate HOW — backend (Fastify/Prisma), frontend (React/Tailwind), CLI, tools, diagrams.',
+  '',
+  'Before using tools, read these resources to ground yourself in the language:',
+  '- specverse://guide — canonical user guide (spec language, CLI reference, convention patterns)',
+  '- specverse://ai-guidance — curated hints for generating valid specs',
+  '- specverse://minimal-example — one minimal .specly showing every feature in ~100 lines',
+  '- specverse://schema — the JSON Schema (draft 2020-12) for .specly validation',
+  '- specverse://cli-reference — every spv CLI subcommand with flags + arguments',
+  '',
+  'Common high-leverage workflows are exposed as MCP prompts (preferred entry point):',
+  '- create: natural-language requirements → minimal .specly',
+  '- analyse: existing codebase → .specly that captures what is implemented',
+  '- materialise: .specly → production code',
+  '- realize: generate deployment configs',
+  '- behavior: generate AI behavior function stubs',
+  '- app-demo: interactive spec creation/modification for the runtime interpreter',
+  '',
+  'Tools map 1:1 to the spv CLI. Key distinctions:',
+  '- validate: check a .specly file parses + matches the schema',
+  '- validate-manifest: check an implementation manifest resolves cleanly',
+  '- validate-bundle: check an entity bundle (schema + examples + tests + docs + behaviour facets)',
+  '- infer: expand a minimal .specly to full architecture (controllers / services / events / views)',
+  '- realize: turn inferred spec + manifest into generated code (Fastify / Prisma / React / CLI / tools)',
+  '- init: scaffold a new project from a template',
+].join('\n');
+
+
 function generateCliRunner(): string {
   return `/**
  * Thin specverse CLI runner.
@@ -377,11 +458,16 @@ export async function callTool(name: string, args: Record<string, any>) {
 `;
 }
 
-function generateResources(): string {
+function generateResources(tools: CLITool[]): string {
+  const cliReference = buildCliReferenceMarkdown(tools);
   return `/**
- * Resource registry — exposes the live SpecVerse schema + user guide as
- * MCP resources. Read lazily from @specverse/entities at request time so
- * the contents always match the installed entities version.
+ * Resource registry — exposes the canonical SpecVerse reference material as
+ * MCP resources:
+ *   - schema           (JSON Schema draft 2020-12, from @specverse/entities)
+ *   - ai-guidance      (curated LLM hints, from @specverse/entities)
+ *   - minimal-example  (one .specly covering all features, from @specverse/entities)
+ *   - guide            (user guide, from @specverse/self)
+ *   - cli-reference    (derived from the spec at realize time, embedded below)
  */
 import { readFileSync } from 'fs';
 import { createRequire } from 'module';
@@ -402,6 +488,13 @@ function resolveEntitiesFile(relative: string): string {
   return join(dirname(pkg), relative);
 }
 
+function resolveSelfFile(relative: string): string {
+  const pkg = require.resolve('@specverse/self/package.json');
+  return join(dirname(pkg), relative);
+}
+
+const CLI_REFERENCE_MARKDOWN = ${JSON.stringify(cliReference)};
+
 export const RESOURCES: Resource[] = [
   {
     uri: 'specverse://schema',
@@ -413,13 +506,43 @@ export const RESOURCES: Resource[] = [
       mimeType: 'application/json',
     }),
   },
+  {
+    uri: 'specverse://ai-guidance',
+    name: 'SpecVerse AI Guidance Schema',
+    description: 'YAML schema annotated with examples and LLM guidance for generating valid specs. Read this before authoring or mutating .specly files.',
+    mimeType: 'application/x-yaml',
+    resolve: () => ({
+      text: readFileSync(resolveEntitiesFile('schema/SPECVERSE-SCHEMA-AI.yaml'), 'utf8'),
+      mimeType: 'application/x-yaml',
+    }),
+  },
+  {
+    uri: 'specverse://minimal-example',
+    name: 'SpecVerse Minimal Example',
+    description: 'One complete minimal .specly demonstrating every feature (~100 lines) — component, models, relationships, lifecycle, CURVED controller, service, view, event, manifest, deployment.',
+    mimeType: 'text/x-yaml',
+    resolve: () => ({
+      text: readFileSync(resolveEntitiesFile('schema/MINIMAL-SYNTAX-REFERENCE.specly'), 'utf8'),
+      mimeType: 'text/x-yaml',
+    }),
+  },
   {
     uri: 'specverse://guide',
     name: 'SpecVerse Complete Guide',
     description: 'The canonical user guide — spec language, convention patterns, CLI reference.',
     mimeType: 'text/markdown',
     resolve: () => ({
-      text: readFileSync(resolveEntitiesFile('schema/SPECVERSE-COMPLETE-GUIDE.md'), 'utf8'),
+      text: readFileSync(resolveSelfFile('docs/guides/SPECVERSE-COMPLETE-GUIDE.md'), 'utf8'),
+      mimeType: 'text/markdown',
+    }),
+  },
+  {
+    uri: 'specverse://cli-reference',
+    name: 'SpecVerse CLI Reference',
+    description: 'Every spv CLI subcommand with its arguments, flags, and exit codes. Derived from the spec at realize time.',
+    mimeType: 'text/markdown',
+    resolve: () => ({
+      text: CLI_REFERENCE_MARKDOWN,
       mimeType: 'text/markdown',
     }),
   },
@@ -439,3 +562,193 @@ export async function readResource(uri: string) {
 }
 `;
 }
+
+/**
+ * Build the cli-reference.md content from the parsed CLI tool list.
+ * Embedded as a string constant in the generated resources.ts so the MCP
+ * server doesn't need filesystem access for it at runtime.
+ */
+function buildCliReferenceMarkdown(tools: CLITool[]): string {
+  const lines: string[] = [];
+  lines.push('# SpecVerse CLI Reference');
+  lines.push('');
+  lines.push('Generated from the self-spec at realize time. Every entry here matches an MCP tool exposed by this server (same name, same input schema).');
+  lines.push('');
+  for (const tool of tools) {
+    const cliCmd = tool.cliArgs.join(' ');
+    lines.push(`## \`spv ${cliCmd}\``);
+    lines.push('');
+    lines.push(tool.description);
+    lines.push('');
+    const props = (tool.inputSchema as any)?.properties || {};
+    const required = new Set(((tool.inputSchema as any)?.required || []) as string[]);
+    const positional = new Set(tool.positional);
+    const argEntries = Object.entries(props) as [string, any][];
+    if (argEntries.length > 0) {
+      lines.push('| Name | Kind | Required | Type | Description |');
+      lines.push('|---|---|---|---|---|');
+      for (const [name, schema] of argEntries) {
+        const kind = positional.has(name) ? 'positional' : 'flag';
+        const req = required.has(name) ? 'yes' : 'no';
+        const type = (schema as any)?.type || 'string';
+        const desc = ((schema as any)?.description || '').replace(/\|/g, '\\|');
+        lines.push(`| \`${name}\` | ${kind} | ${req} | ${type} | ${desc} |`);
+      }
+      lines.push('');
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Emit prompts.ts — loads the canonical workflow prompts from
+ * @specverse/engines/assets/prompts/core/standard/default/ at module-init
+ * time. Each YAML prompt becomes one MCP prompt; the declared
+ * {{template variables}} surface as MCP prompt arguments the client fills.
+ * Schema paths ({{aiSchemaPath}}, {{referenceSchemaPath}},
+ * {{referenceExamplePath}}) are auto-filled with package-relative paths so
+ * the caller doesn't have to know where they live on disk.
+ */
+function generatePrompts(): string {
+  return `/**
+ * Prompt registry — reads the canonical workflow prompts from
+ * @specverse/engines/assets/prompts/core/standard/default/ at startup and
+ * serves them as MCP prompts. Each YAML file (create, analyse, materialise,
+ * realize, behavior, app-demo) becomes one invocable prompt.
+ */
+import { readdirSync, readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname, join, basename } from 'path';
+import { load as yamlLoad } from 'js-yaml';
+
+const require = createRequire(import.meta.url);
+
+export interface PromptArgument {
+  name: string;
+  description?: string;
+  required: boolean;
+}
+
+export interface Prompt {
+  name: string;
+  description: string;
+  arguments: PromptArgument[];
+  source: any;  // parsed YAML — kept so getPrompt can re-render
+}
+
+function resolveEntitiesFile(relative: string): string {
+  const pkg = require.resolve('@specverse/entities/package.json');
+  return join(dirname(pkg), relative);
+}
+
+function resolveEnginesDir(relative: string): string {
+  const pkg = require.resolve('@specverse/engines/package.json');
+  return join(dirname(pkg), relative);
+}
+
+// Auto-filled template vars — paths into @specverse/entities/schema/
+const SCHEMA_VAR_PATHS: Record<string, string> = {
+  aiSchemaPath: resolveEntitiesFile('schema/SPECVERSE-SCHEMA-AI.yaml'),
+  referenceSchemaPath: resolveEntitiesFile('schema/MINIMAL-SYNTAX-REFERENCE.specly'),
+  referenceExamplePath: resolveEntitiesFile('schema/MINIMAL-SYNTAX-REFERENCE.specly'),
+};
+
+// User-facing vars the server does NOT auto-fill — surfaced as MCP prompt args.
+const USER_FACING = new Set<string>([
+  ...Object.keys(SCHEMA_VAR_PATHS),
+]);
+
+function loadPrompts(): Prompt[] {
+  const promptsDir = resolveEnginesDir('assets/prompts/core/standard/default');
+  const entries = readdirSync(promptsDir).filter(f => f.endsWith('.prompt.yaml'));
+  const prompts: Prompt[] = [];
+  for (const entry of entries) {
+    const full = join(promptsDir, entry);
+    try {
+      const parsed = yamlLoad(readFileSync(full, 'utf8')) as any;
+      if (!parsed?.name) continue;
+      const args = deriveArguments(parsed);
+      prompts.push({
+        name: parsed.name,
+        description: parsed.description || \`SpecVerse \${parsed.name} workflow\`,
+        arguments: args,
+        source: parsed,
+      });
+    } catch (err) {
+      // One bad prompt shouldn't kill the server; skip it.
+      console.error(\`[prompts] skipping \${basename(entry)}: \${(err as Error).message}\`);
+    }
+  }
+  return prompts;
+}
+
+/**
+ * Every SpecVerse prompt YAML declares user.variables[] in the canonical shape
+ * { name, type?, required?, description?, default? }. We surface the declared
+ * list verbatim, filtering out auto-filled schema-path vars.
+ */
+function deriveArguments(parsed: any): PromptArgument[] {
+  const declared = parsed?.user?.variables;
+  if (!Array.isArray(declared)) return [];
+  return declared
+    .filter((v: any) => v && typeof v === 'object' && typeof v.name === 'string')
+    .filter((v: any) => !USER_FACING.has(v.name))
+    .map((v: any) => ({
+      name: v.name,
+      description: v.description || inferVarDescription(v.name, parsed),
+      required: v.required !== false,
+    }));
+}
+
+function inferVarDescription(varName: string, parsed: any): string {
+  // Friendly defaults for the known common vars; fall back to a humanised
+  // version of the variable name.
+  const defaults: Record<string, string> = {
+    requirements: 'Natural-language requirements to extract a specification from',
+    scale: 'Project scale — personal, business, or enterprise',
+    preferredTech: 'Preferred technology stack hint (e.g. "nextjs", "nestjs", "fastify+prisma", "auto")',
+    implementationPath: 'Path to the existing codebase to reverse-engineer into a .specly',
+    specPath: 'Path to an existing .specly file',
+    manifestPath: 'Path to an implementation manifest (manifests/implementation.yaml)',
+    outputDir: 'Output directory for generated artifacts',
+    modelName: 'Name of the model the behavior is attached to',
+    behaviorName: 'Name of the behavior method on the model',
+  };
+  if (defaults[varName]) return defaults[varName];
+  return varName.replace(/([A-Z])/g, ' $1').replace(/^./, c => c.toUpperCase());
+}
+
+function substitute(text: string, values: Record<string, string>): string {
+  return text.replace(/\\{\\{\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\}\\}/g, (match, name) => {
+    if (name in values) return values[name];
+    if (name in SCHEMA_VAR_PATHS) return SCHEMA_VAR_PATHS[name];
+    return match; // unknown var — leave the placeholder so it's visible
+  });
+}
+
+function renderMessages(prompt: Prompt, args: Record<string, string>): { role: 'user'; content: { type: 'text'; text: string } }[] {
+  const src = prompt.source;
+  const sections: string[] = [];
+  if (src?.system?.role) sections.push(\`[System role]\\n\${substitute(src.system.role, args).trim()}\`);
+  if (src?.system?.context) sections.push(\`[Context]\\n\${substitute(src.system.context, args).trim()}\`);
+  if (src?.user?.template) sections.push(substitute(src.user.template, args).trim());
+  const text = sections.filter(Boolean).join('\\n\\n');
+  return [{ role: 'user', content: { type: 'text', text } }];
+}
+
+export const PROMPTS: Prompt[] = loadPrompts();
+
+const BY_NAME = new Map<string, Prompt>(PROMPTS.map(p => [p.name, p]));
+
+export async function getPrompt(name: string, args: Record<string, string>) {
+  const prompt = BY_NAME.get(name);
+  if (!prompt) {
+    throw new Error(\`Unknown prompt: \${name}\`);
+  }
+  return {
+    description: prompt.description,
+    messages: renderMessages(prompt, args),
+  };
+}
+`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@specverse/engines",
-  "version": "5.0.2",
-  "description": "SpecVerse toolchain \u2014 parser, inference, realize, generators, AI, registry",
+  "version": "5.2.0",
+  "description": "SpecVerse toolchain \u2014 parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,6 +35,10 @@
       "types": "./dist/registry/index.d.ts",
       "import": "./dist/registry/index.js"
     },
+    "./bundles": {
+      "types": "./dist/bundles/index.d.ts",
+      "import": "./dist/bundles/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -42,9 +46,9 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@specverse/entities": "^5.0.0",
-    "@specverse/runtime": "^5.0.0",
-    "@specverse/types": "^5.0.0",
+    "@specverse/entities": "^5.1.0",
+    "@specverse/runtime": "^5.0.1",
+    "@specverse/types": "^5.1.0",
     "ajv": "^8.17.0",
     "ajv-formats": "^2.1.0",
     "glob": "^10.0.0",

package/assets/examples/09-api/ai-spec.yaml

@@ -1,194 +0,0 @@
-metadata:
-  component: SpecVerseFundamentals
-  version: 1.0.0
-  description: 'Example 01-01: Basic model definition with attributes'
-  tags: []
-imports:
-  - from: '@specverse/primitives'
-    select:
-      - Money
-exports: []
-models:
-  - name: Product
-    attributes:
-      - name: id
-        type: UUID
-        constraints:
-          required: true
-          unique: false
-          pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
-          format: uuid
-        dbMapping:
-          columnName: id
-          columnType: UUID
-          index: false
-          nullable: false
-        validation:
-          rules:
-            - required
-        metadata:
-          encrypted: false
-          audit: false
-      - name: name
-        type: String
-        constraints:
-          required: true
-          unique: false
-        dbMapping:
-          columnName: name
-          columnType: VARCHAR(255)
-          index: false
-          nullable: false
-        validation:
-          rules:
-            - required
-        metadata:
-          encrypted: false
-          audit: false
-      - name: summary
-        type: String
-        constraints:
-          required: false
-          unique: false
-        dbMapping:
-          columnName: summary
-          columnType: VARCHAR(255)
-          index: false
-          nullable: true
-        validation:
-          rules: []
-        metadata:
-          encrypted: false
-          audit: false
-      - name: price
-        type: Money
-        constraints:
-          required: true
-          unique: false
-        dbMapping:
-          columnName: price
-          columnType: VARCHAR(255)
-          index: false
-          nullable: false
-        validation:
-          rules:
-            - required
-        metadata:
-          encrypted: false
-          audit: false
-      - name: inStock
-        type: Boolean
-        constraints:
-          required: false
-          unique: false
-        dbMapping:
-          columnName: in_stock
-          columnType: BOOLEAN
-          index: false
-          nullable: true
-          defaultValue: 'true'
-        validation:
-          rules: []
-        metadata:
-          encrypted: false
-          audit: false
-      - name: category
-        type: String
-        constraints:
-          required: true
-          unique: false
-        dbMapping:
-          columnName: category
-          columnType: VARCHAR(255)
-          index: false
-          nullable: false
-        validation:
-          rules:
-            - required
-        metadata:
-          encrypted: false
-          audit: false
-      - name: contactEmail
-        type: Email
-        constraints:
-          required: false
-          unique: false
-          pattern: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
-          format: email
-        dbMapping:
-          columnName: contact_email
-          columnType: VARCHAR(255)
-          index: false
-          nullable: true
-        validation:
-          rules:
-            - email
-        metadata:
-          encrypted: false
-          audit: false
-    relationships: []
-    behaviors:
-      - name: attachProfile
-        signature: 'attachProfile(profileName: String): Promise<Boolean>'
-        implementation:
-          preconditions:
-            - Profile exists and is compatible with this model
-          postconditions:
-            - Profile is attached
-            - Profile attributes are available
-          sideEffects: []
-          steps: []
-          transactional: true
-        metadata:
-          async: true
-          cacheable: false
-          idempotent: false
-      - name: detachProfile
-        signature: 'detachProfile(profileName: String): Promise<Boolean>'
-        implementation:
-          preconditions:
-            - Profile is currently attached
-          postconditions:
-            - Profile is detached
-            - Profile attributes are no longer available
-          sideEffects: []
-          steps: []
-          transactional: true
-        metadata:
-          async: true
-          cacheable: false
-          idempotent: false
-      - name: hasProfile
-        signature: 'hasProfile(profileName: String): Promise<Boolean>'
-        implementation:
-          preconditions: []
-          postconditions: []
-          sideEffects: []
-          steps: []
-          transactional: false
-        metadata:
-          async: true
-          cacheable: false
-          idempotent: false
-    lifecycle:
-      states: []
-      transitions: {}
-      currentStateField: state
-    dbMapping:
-      tableName: products
-      indexes: []
-controllers: []
-services: []
-views: []
-events: []
-infrastructure:
-  database:
-    type: postgresql
-    migrations: true
-    seedData: false
-  messaging:
-    type: rabbitmq
-    queues: []
-  caching:
-    type: redis
-    ttl: 3600