@specverse/engines 4.3.5 → 5.0.1

package/dist/libs/instance-factories/tools/templates/vscode/vscode-extension-generator.js

@@ -1,22 +1,63 @@
-import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, copyFileSync } from "fs";
+import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, copyFileSync, unlinkSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 const __generatorDir = dirname(fileURLToPath(import.meta.url));
+const __require = createRequire(import.meta.url);
+function resolveComposedSchemaPath() {
+  try {
+    const entitiesPkg = __require.resolve("@specverse/entities/package.json");
+    const schemaPath = join(dirname(entitiesPkg), "schema", "SPECVERSE-SCHEMA.json");
+    if (existsSync(schemaPath)) return schemaPath;
+  } catch {
+  }
+  return null;
+}
 function generateVSCodeExtension(context) {
   const { spec, outputDir } = context;
   const extensionDir = join(outputDir || ".", "tools", "vscode-extension");
   if (!existsSync(extensionDir)) mkdirSync(extensionDir, { recursive: true });
   const distribution = extractDistribution(spec);
   let cliCommands = [];
+  const submenuDefs = [];
   if (distribution?.commands) {
-    cliCommands = distribution.commands.map((cmd) => {
+    const specCommandsByName = buildCLICommandMap(spec);
+    const standardByName = new Map(
+      getStandardCommands().map((c) => [c.command, c])
+    );
+    cliCommands = distribution.commands.flatMap((cmd) => {
       const parts = (cmd.from || cmd.command || "").split(".");
       const name = parts[parts.length - 1] || "unknown";
-      return {
-        command: `specverse.${name}`,
-        title: cmd.title || `${capitalize(name)}: ${cmd.description || ""}`,
+      const specNode = findSpecCommand(spec, cmd.from || name);
+      const subs = specNode?.subcommands;
+      if (subs && Object.keys(subs).length > 0) {
+        const submenuId = `specverse.${name}`;
+        const submenuLabel = cmd.title || specNode?.description || capitalize(name);
+        submenuDefs.push({ id: submenuId, label: capitalize(name) });
+        return Object.entries(subs).map(([childName, childDef]) => ({
+          command: `specverse.${name}.${childName}`,
+          title: `${capitalize(name)} ${capitalize(childName)}`,
+          category: "SpecVerse",
+          submenu: submenuId,
+          submenuLabel
+        }));
+      }
+      const commandId = `specverse.${name}`;
+      let title = cmd.title;
+      if (!title && cmd.from) {
+        const specCmd = specCommandsByName.get(cmd.from);
+        if (specCmd?.description) title = specCmd.description;
+      }
+      if (!title) {
+        const std = standardByName.get(commandId);
+        if (std) title = std.title;
+      }
+      if (!title) title = capitalize(name);
+      return [{
+        command: commandId,
+        title,
         category: "SpecVerse"
-      };
+      }];
     });
   }
   if (cliCommands.length === 0) {
@@ -44,6 +85,56 @@ function generateVSCodeExtension(context) {
         scopeName: lang.grammar,
         path: `./syntaxes/${lang.id}.tmLanguage.json`
       }));
+      packageJson.activationEvents = [];
+      const fileMatch = distribution.languages.flatMap((lang) => (lang.extensions || []).map((ext) => `*${ext}`));
+      if (fileMatch.length > 0) {
+        packageJson.contributes.jsonValidation = [{
+          fileMatch,
+          url: "./schemas/specverse-schema.json"
+        }];
+      }
+      const extnames = distribution.languages.flatMap((lang) => lang.extensions || []);
+      const langIds = distribution.languages.map((lang) => lang.id);
+      const explorerWhen = extnames.map((e) => `resourceExtname == ${e}`).join(" || ");
+      const editorWhen = langIds.map((id) => `editorLangId == ${id}`).join(" || ");
+      const seenSubmenus = /* @__PURE__ */ new Set();
+      const topEntries = [];
+      for (const c of cliCommands) {
+        if (c.submenu) {
+          if (!seenSubmenus.has(c.submenu)) {
+            seenSubmenus.add(c.submenu);
+            topEntries.push({ submenu: c.submenu });
+          }
+        } else {
+          topEntries.push({ command: c.command });
+        }
+      }
+      if (topEntries.length > 0 && (explorerWhen || editorWhen)) {
+        const explorerMenu = topEntries.map((e, i) => ({
+          ...e.submenu ? { submenu: e.submenu } : { command: e.command },
+          when: explorerWhen,
+          group: `specverse@${i + 1}`
+        }));
+        const editorMenu = topEntries.map((e, i) => ({
+          ...e.submenu ? { submenu: e.submenu } : { command: e.command },
+          when: editorWhen,
+          group: `specverse@${i + 1}`
+        }));
+        const menus = {
+          "explorer/context": explorerMenu,
+          "editor/context": editorMenu
+        };
+        for (const sub of submenuDefs) {
+          menus[sub.id] = cliCommands.filter((c) => c.submenu === sub.id).map((c) => ({ command: c.command }));
+        }
+        packageJson.contributes.menus = menus;
+        if (submenuDefs.length > 0) {
+          packageJson.contributes.submenus = submenuDefs.map((s) => ({
+            id: s.id,
+            label: s.label
+          }));
+        }
+      }
     }
     if (distribution.themes && distribution.themes.length > 0) {
       packageJson.contributes.themes = distribution.themes.map((theme) => ({
@@ -61,6 +152,29 @@ function generateVSCodeExtension(context) {
   if (existsSync(staticDir)) {
     copyRecursive(staticDir, extensionDir);
   }
+  const schemaSrc = resolveComposedSchemaPath();
+  if (schemaSrc) {
+    const schemasDir = join(extensionDir, "schemas");
+    if (!existsSync(schemasDir)) mkdirSync(schemasDir, { recursive: true });
+    copyFileSync(schemaSrc, join(schemasDir, "specverse-schema.json"));
+  }
+  if (distribution?.languages && distribution.languages.length > 0) {
+    const syntaxesDir = join(extensionDir, "syntaxes");
+    if (existsSync(syntaxesDir)) {
+      const langId = distribution.languages[0].id;
+      const targetName = `${langId}.tmLanguage.json`;
+      const targetPath = join(syntaxesDir, targetName);
+      if (!existsSync(targetPath)) {
+        const existing = readdirSync(syntaxesDir).find(
+          (f) => f.endsWith(".tmLanguage.json") && f !== targetName
+        );
+        if (existing) {
+          copyFileSync(join(syntaxesDir, existing), targetPath);
+          unlinkSync(join(syntaxesDir, existing));
+        }
+      }
+    }
+  }
   const srcDir = join(extensionDir, "src");
   if (!existsSync(srcDir)) mkdirSync(srcDir, { recursive: true });
   const extTs = join(staticDir, "extension.ts");
@@ -102,6 +216,56 @@ function extractDistribution(spec) {
   }
   return allDistributions.length > 0 ? allDistributions[0] : null;
 }
+function findSpecCommand(spec, ref) {
+  if (!ref) return null;
+  const parts = ref.split(".");
+  const target = parts[parts.length - 1];
+  const components = spec?.components || {};
+  const componentList = Array.isArray(components) ? components : Object.entries(components).map(([name, data]) => ({ name, ...data }));
+  for (const comp of componentList) {
+    const cliCommands = comp?.commands;
+    if (!cliCommands) continue;
+    for (const [, rootDef] of Object.entries(cliCommands)) {
+      const subcommands = rootDef?.subcommands || {};
+      if (subcommands[target]) return subcommands[target];
+    }
+  }
+  return null;
+}
+function buildCLICommandMap(spec) {
+  const map = /* @__PURE__ */ new Map();
+  const components = spec?.components || {};
+  const componentList = Array.isArray(components) ? components : Object.entries(components).map(([name, data]) => ({ name, ...data }));
+  for (const comp of componentList) {
+    const compName = comp.name || "";
+    const cliCommands = comp?.commands;
+    if (!cliCommands) continue;
+    for (const [rootName, rootDef] of Object.entries(cliCommands)) {
+      const subcommands = rootDef?.subcommands || {};
+      for (const [subName, subDef] of Object.entries(subcommands)) {
+        const sub = subDef;
+        const entry = { description: sub.description, title: sub.title };
+        if (compName) map.set(`${compName}.${subName}`, entry);
+        map.set(`${rootName}.${subName}`, entry);
+        if (!map.has(subName)) map.set(subName, entry);
+        const nestedSubs = sub?.subcommands;
+        if (nestedSubs) {
+          for (const [nestedName, nestedDef] of Object.entries(nestedSubs)) {
+            const nestedEntry = {
+              description: nestedDef.description,
+              title: nestedDef.title
+            };
+            const qualified = `${subName}.${nestedName}`;
+            if (compName) map.set(`${compName}.${qualified}`, nestedEntry);
+            map.set(`${rootName}.${qualified}`, nestedEntry);
+            if (!map.has(qualified)) map.set(qualified, nestedEntry);
+          }
+        }
+      }
+    }
+  }
+  return map;
+}
 function extractCLICommands(spec) {
   const commands = [];
   const components = spec?.components || {};
@@ -159,7 +323,7 @@ function generatePackageJson(commands, _entityTypes, specVersion = "1.0.0") {
     publisher: "specverse",
     engines: { vscode: "^1.80.0" },
     categories: ["Programming Languages", "Linters", "Snippets"],
-    activationEvents: ["onLanguage:specverse"],
+    activationEvents: [],
     main: "./dist/extension.js",
     contributes: {
       languages: [{
@@ -175,7 +339,7 @@ function generatePackageJson(commands, _entityTypes, specVersion = "1.0.0") {
       }],
       jsonValidation: [{
         fileMatch: ["*.specly", "*.specverse"],
-        url: "./schemas/specverse-v3-schema.json"
+        url: "./schemas/specverse-schema.json"
       }],
       themes: [
         { label: "SpecVerse Dark", uiTheme: "vs-dark", path: "./themes/specverse-complete-theme.json" },

package/dist/libs/instance-factories/tools/vscode.yaml

@@ -9,7 +9,7 @@ metadata:
   tags: [vscode, ide, extension, language-support]
 
 compatibility:
-  specverse: "^4.0.0"
+  specverse: ">=4.0.0"
   node: ">=18.0.0"
 
 capabilities:

package/libs/instance-factories/cli/templates/commander/command-generator.ts

@@ -249,7 +249,7 @@ import type { ParserEngine, InferenceEngine } from '@specverse/types';`,
   },
   realize: {
     imports: `import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve, join, dirname } from 'path';
 import { EngineRegistry } from '@specverse/entities';
 import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/types';`,
     handler: `if (!existsSync(file)) {
@@ -386,10 +386,32 @@ import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/ty
         }
         const inferredSpec = { ...componentData, componentName, components: inferredYaml?.components || {} };
 
-        // Realize — let the realize engine handle its own library
-        const manifestPath = options.manifest || resolve((process.env.SPECVERSE_USER_CWD || process.cwd()), 'manifests/implementation.yaml');
-        if (!existsSync(manifestPath)) {
-          console.error('Manifest not found:', manifestPath);
+        // Realize — let the realize engine handle its own library.
+        // Locate the nearest implementation manifest by walking up from the
+        // spec file, then falling back to the user's cwd. This lets the same
+        // invocation work from any subdirectory (CLI, VSCode right-click, CI).
+        const cwd = process.env.SPECVERSE_USER_CWD || process.cwd();
+        let manifestPath: string | null = null;
+        if (options.manifest) {
+          manifestPath = resolve(cwd, options.manifest);
+        } else {
+          let searchDir = dirname(resolve(file));
+          while (true) {
+            const inManifests = join(searchDir, 'manifests', 'implementation.yaml');
+            if (existsSync(inManifests)) { manifestPath = inManifests; break; }
+            const flat = join(searchDir, 'implementation.yaml');
+            if (existsSync(flat)) { manifestPath = flat; break; }
+            const parent = dirname(searchDir);
+            if (parent === searchDir) break;
+            searchDir = parent;
+          }
+          if (!manifestPath) {
+            const cwdBased = resolve(cwd, 'manifests/implementation.yaml');
+            if (existsSync(cwdBased)) manifestPath = cwdBased;
+          }
+        }
+        if (!manifestPath || !existsSync(manifestPath)) {
+          console.error('Manifest not found. Looked for manifests/implementation.yaml walking up from the spec file, then in ' + cwd);
           process.exit(1);
         }
 

package/libs/instance-factories/tools/README.md

@@ -24,7 +24,7 @@ The static framework includes:
 
 The generated MCP server exposes tools like `specverse-create`, `specverse-analyse`, `specverse-validate`, `specverse-realize`, and `specverse-suggest`, plus resources for schema, conventions, library catalog, and prompt templates.
 
-**Package**: `@specverse/mcp` v3.5.2, depends on `@modelcontextprotocol/sdk` and `@specverse/lang`.
+**Package**: `@specverse/mcp` v3.5.2, depends on `@modelcontextprotocol/sdk` and `@specverse/engines`.
 
 ### VSCode Extension (`templates/vscode/`)
 

package/libs/instance-factories/tools/mcp.yaml

@@ -9,7 +9,7 @@ metadata:
   tags: [mcp, ai, tools, claude, llm]
 
 compatibility:
-  specverse: "^4.0.0"
+  specverse: ">=4.0.0"
   node: ">=18.0.0"
 
 capabilities: