@specverse/engines 4.1.19 → 4.1.21

package/libs/instance-factories/applications/templates/react/package-json-generator.ts

@@ -44,7 +44,7 @@ export default function generatePackageJson(context: TemplateContext): string {
       "postcss": "^8.4.47",
       "tailwindcss": "^3.4.13",
       "typescript": "^5.2.0",
-      "vite": "^5.0.0",
+      "vite": "^6.0.0",
       "eslint": "^8.53.0",
       "@typescript-eslint/eslint-plugin": "^6.10.0",
       "@typescript-eslint/parser": "^6.10.0",

package/libs/instance-factories/applications/templates/react/runtime-package-json-generator.ts

@@ -53,7 +53,7 @@ export default function generateRuntimePackageJson(context: TemplateContext): st
       "postcss": "^8.4.47",
       "tailwindcss": "^3.4.13",
       "typescript": "^5.2.0",
-      "vite": "^5.0.0",
+      "vite": "^6.0.0",
       "eslint": "^8.53.0",
       "@typescript-eslint/eslint-plugin": "^6.10.0",
       "@typescript-eslint/parser": "^6.10.0",

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

@@ -843,6 +843,87 @@ import { EngineRegistry } from '@specverse/entities';`,
           console.log(template);
         }`
   },
+  'ai.regenerate': {
+    imports: `import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { EngineRegistry } from '@specverse/entities';
+import type { ParserEngine } from '@specverse/types';`,
+    handler: `// Parse Owner.functionName — or just Owner with --all
+        const target = fn;
+        const dotIdx = target.indexOf('.');
+        const ownerName = dotIdx >= 0 ? target.slice(0, dotIdx) : target;
+        const functionName = dotIdx >= 0 ? target.slice(dotIdx + 1) : null;
+        if (!functionName && !options.all) {
+          console.error('Function must be specified as Owner.functionName, or use --all to regenerate every AI function in the owner.');
+          process.exit(1);
+        }
+
+        // Resolve spec file — default to specs/main-inferred.specly next to cwd
+        const userCwd = process.env.SPECVERSE_USER_CWD || process.cwd();
+        const specCandidates = options.spec
+          ? [resolve(userCwd, options.spec)]
+          : [resolve(userCwd, 'specs/main-inferred.specly'), resolve(userCwd, 'specs/main.specly')];
+        const specPath = specCandidates.find(p => existsSync(p));
+        if (!specPath) {
+          console.error('Spec not found. Tried: ' + specCandidates.join(', '));
+          console.error('Pass --spec <file> or run from a project root with specs/main.specly.');
+          process.exit(1);
+        }
+        console.log('Using spec: ' + specPath);
+
+        const registry = new EngineRegistry();
+        await registry.discover();
+        const parser = registry.getEngineForCapability('parse') as ParserEngine;
+        if (!parser) { console.error('No parser engine found.'); process.exit(1); }
+        await parser.initialize();
+
+        const specContent = readFileSync(specPath, 'utf8');
+        const parseResult = parser.parseContent(specContent, specPath);
+        if (parseResult.errors.length > 0) {
+          console.error('Invalid spec:');
+          parseResult.errors.forEach((e: string) => console.error('  ' + e));
+          process.exit(1);
+        }
+
+        // Flatten components down to a realize-shaped spec
+        // (controllers, services, models at top level) — matches what
+        // regenerateBehavior expects. Collections may be arrays (parser
+        // output) or objects (inferred spec); preserve the incoming shape.
+        const ast: any = parseResult.ast;
+        const flat: any = { ...ast };
+        const components = ast?.components || {};
+        for (const comp of Object.values(components) as any[]) {
+          for (const key of ['models', 'controllers', 'services']) {
+            const collection = comp?.[key];
+            if (!collection) continue;
+            if (Array.isArray(collection)) {
+              flat[key] = [...(Array.isArray(flat[key]) ? flat[key] : []), ...collection];
+            } else {
+              flat[key] = { ...(flat[key] && !Array.isArray(flat[key]) ? flat[key] : {}), ...collection };
+            }
+          }
+        }
+
+        const { regenerateBehavior } = await import('@specverse/engines/ai');
+        const outputDir = resolve(userCwd, options.output || 'generated/code');
+        try {
+          const result = await regenerateBehavior({
+            spec: flat,
+            ownerName,
+            targetFunction: options.all ? null : functionName,
+            outputDir,
+            allFunctions: !!options.all,
+          });
+          console.log(\`✅ Regenerated \${result.filePath}\`);
+          console.log(\`   Owner: \${ownerName}\`);
+          console.log(\`   Unmatched functions: \${result.unmatchedCount}\`);
+          console.log(\`   Target: \${options.all ? 'all' : functionName}\`);
+          console.log(\`   Cache entries cleared: \${result.cacheCleared}\`);
+        } catch (err: any) {
+          console.error('Regeneration failed: ' + (err?.message || err));
+          process.exit(1);
+        }`
+  },
   // === session subcommands ===
   'session.create': {
     imports: `import { EngineRegistry } from '@specverse/entities';`,

package/libs/instance-factories/services/templates/prisma/ai-behaviors-generator.ts

@@ -20,8 +20,8 @@
 import type { TemplateContext } from '@specverse/types';
 import { matchStep, type StepContext } from './step-conventions.js';
 import { createHash } from 'crypto';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { dirname, join } from 'path';
 
 /**
  * Validate generated TypeScript using esbuild's transform.
@@ -374,3 +374,214 @@ const prisma = new PrismaClient();
 ${functions.join('\n\n')}
 `;
 }
+
+/**
+ * Regenerate a single owner's AI behaviors file, optionally targeting one
+ * function for cache bypass.
+ *
+ * Used by `specverse ai regenerate <Owner.fn>`. Works on both controllers
+ * (actions) and services (operations). When `targetFunction` is provided,
+ * its cache entry is deleted before regeneration so Claude is re-consulted
+ * for that one function; all other functions in the owner reuse their
+ * cache. When `targetFunction` is null, the whole file is rebuilt without
+ * touching the cache.
+ *
+ * `spec` should be the inferred spec (normalized shape: `controllers` and
+ * `services` are either objects keyed by name or arrays with `.name`).
+ */
+export async function regenerateAiBehaviors(opts: {
+  spec: any;
+  ownerName: string;
+  targetFunction: string | null;
+  outputDir: string;
+  allFunctions?: boolean;
+}): Promise<{
+  filePath: string;
+  targetFound: boolean;
+  unmatchedCount: number;
+  cacheCleared: number;
+}> {
+  const { spec, ownerName, targetFunction, outputDir, allFunctions } = opts;
+
+  // Resolve the owner — could be a controller (has .actions) or a service (has .operations).
+  // Accept both the "object keyed by name" and "array with .name" shapes.
+  const findOwner = (collection: any): any => {
+    if (!collection) return null;
+    if (Array.isArray(collection)) return collection.find((c: any) => c?.name === ownerName) || null;
+    return collection[ownerName] || null;
+  };
+  const controller = findOwner(spec.controllers);
+  const service = findOwner(spec.services);
+  if (!controller && !service) {
+    throw new Error(
+      `Owner '${ownerName}' not found in spec. Looked in controllers and services — ` +
+      `check that the name matches exactly (case-sensitive) and that you're pointing ` +
+      `at an inferred spec (try 'specs/main-inferred.specly').`
+    );
+  }
+
+  // Build the unmatched-function list the same way realize does.
+  type UnmatchedFn = {
+    functionName: string;
+    step: string;
+    operationName: string;
+    parameterNames: string[];
+    inputs: string[];
+    returns?: Record<string, string> | string;
+    modelName: string;
+  };
+  const unmatched: UnmatchedFn[] = [];
+  const allModels: string[] = Object.keys(spec.models || {});
+
+  if (controller) {
+    const modelName = controller.model || controller.modelReference || ownerName.replace(/Controller$/, '');
+    const modelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+    const actions = controller.actions || {};
+    for (const [actionName, action] of Object.entries(actions) as [string, any][]) {
+      const steps = action.steps || [];
+      const parameterNames = Object.keys(action.parameters || {});
+      const declaredVars = new Set<string>();
+      const preconditions = action.requires || action.preconditions || [];
+      for (const pc of preconditions) {
+        const m = typeof pc === 'string' ? pc.match(/^(\w+)\s+(?:exists|is\s+\w+)$/i) : null;
+        if (m) declaredVars.add(m[1].charAt(0).toLowerCase() + m[1].slice(1));
+      }
+      for (let i = 0; i < steps.length; i++) {
+        const stepInput = steps[i];
+        const stepText = typeof stepInput === 'string' ? stepInput : stepInput?.step;
+        const stepReturns = typeof stepInput === 'object' ? stepInput?.returns : undefined;
+        if (typeof stepText !== 'string') continue;
+        const ctx: StepContext = {
+          modelName,
+          prismaModel: modelVar,
+          serviceName: ownerName,
+          operationName: actionName,
+          stepNum: i + 1,
+          parameterNames,
+          declaredVars,
+          resultName: typeof stepInput === 'object' ? stepInput?.as : undefined,
+        };
+        const result = matchStep(stepText, ctx);
+        if (!result.matched && result.functionName) {
+          if (!unmatched.find(f => f.functionName === result.functionName)) {
+            unmatched.push({
+              functionName: result.functionName,
+              step: stepText,
+              operationName: actionName,
+              parameterNames,
+              inputs: result.inputs || [],
+              returns: stepReturns,
+              modelName,
+            });
+          }
+        }
+      }
+    }
+  } else if (service) {
+    // Service operations share the same matchStep logic but without a model prefix.
+    const modelName = service.name?.replace(/Service$/, '') || ownerName;
+    const operations = service.operations || {};
+    const opEntries: [string, any][] = Array.isArray(operations)
+      ? operations.map((op: any) => [op.name, op])
+      : Object.entries(operations);
+    for (const [opName, operation] of opEntries) {
+      const steps = operation.steps || operation.implementation?.steps || [];
+      const parameterNames = Object.keys(operation.parameters || {});
+      const declaredVars = new Set<string>();
+      const preconditions = operation.requires || operation.preconditions || [];
+      for (const pc of preconditions) {
+        const m = typeof pc === 'string' ? pc.match(/^(\w+)\s+(?:exists|is\s+\w+)$/i) : null;
+        if (m) declaredVars.add(m[1].charAt(0).toLowerCase() + m[1].slice(1));
+      }
+      for (let i = 0; i < steps.length; i++) {
+        const stepInput = steps[i];
+        const stepText = typeof stepInput === 'string' ? stepInput : stepInput?.step;
+        const stepReturns = typeof stepInput === 'object' ? stepInput?.returns : undefined;
+        if (typeof stepText !== 'string') continue;
+        const ctx: StepContext = {
+          modelName,
+          prismaModel: modelName.charAt(0).toLowerCase() + modelName.slice(1),
+          serviceName: ownerName,
+          operationName: opName,
+          stepNum: i + 1,
+          parameterNames,
+          declaredVars,
+          resultName: typeof stepInput === 'object' ? stepInput?.as : undefined,
+        };
+        const result = matchStep(stepText, ctx);
+        if (!result.matched && result.functionName) {
+          if (!unmatched.find(f => f.functionName === result.functionName)) {
+            unmatched.push({
+              functionName: result.functionName,
+              step: stepText,
+              operationName: opName,
+              parameterNames,
+              inputs: result.inputs || [],
+              returns: stepReturns,
+              modelName: ownerName,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  if (unmatched.length === 0) {
+    throw new Error(
+      `No AI behaviors to regenerate for '${ownerName}'. All of its steps match ` +
+      `built-in convention patterns (see step-conventions.ts). If you expected an ` +
+      `AI-generated function, double-check the spec step text.`
+    );
+  }
+
+  // Find the target function (unless regenerating the whole owner)
+  const targetFound = !targetFunction || unmatched.some(f => f.functionName === targetFunction);
+  if (targetFunction && !targetFound) {
+    const known = unmatched.map(f => f.functionName).join(', ');
+    throw new Error(
+      `Function '${targetFunction}' not found among '${ownerName}' unmatched functions. ` +
+      `Known: ${known || '(none)'}.`
+    );
+  }
+
+  // Delete the cache entry for the target function (or all of them if --all)
+  // so Claude is re-consulted. Other cache entries are untouched so other
+  // functions reuse their previous output.
+  let cacheCleared = 0;
+  const functionsToInvalidate = allFunctions
+    ? unmatched.map(f => f.functionName)
+    : targetFunction ? [targetFunction] : [];
+  for (const fnName of functionsToInvalidate) {
+    const fn = unmatched.find(f => f.functionName === fnName)!;
+    const key = cacheKey(fn.step, fn.modelName, fn.operationName, fn.functionName, fn.inputs);
+    const path = join(cacheDir(), `${key}.ts`);
+    if (existsSync(path)) {
+      try {
+        unlinkSync(path);
+        cacheCleared++;
+      } catch (err: any) {
+        console.warn(`      [ai-cache] failed to delete ${path}: ${err?.message || err}`);
+      }
+    }
+  }
+
+  // Regenerate the full file (cache hits reuse output for non-target functions)
+  const code = await generateAiBehaviorsFile({
+    ownerName,
+    unmatchedFunctions: unmatched,
+    availableModels: allModels,
+    spec,
+  });
+
+  const filePath = join(outputDir, 'backend', 'src', 'behaviors', `${ownerName}.ai.ts`);
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, code, 'utf8');
+
+  return {
+    filePath,
+    targetFound,
+    unmatchedCount: unmatched.length,
+    cacheCleared,
+  };
+}

package/libs/instance-factories/tools/templates/mcp/static/package.json

@@ -58,10 +58,10 @@
     "@types/node": "^20.19.11",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
-    "@vitest/coverage-v8": "^1.6.1",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^8.57.0",
     "typescript": "^5.9.2",
-    "vitest": "^1.6.1"
+    "vitest": "^3.2.4"
   },
   "files": [
     "dist/local/",

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

@@ -257,7 +257,13 @@ function generatePackageJson(
     devDependencies: {
       '@types/vscode': '^1.80.0',
       '@vscode/vsce': '^3.0.0',
-      esbuild: '^0.19.0',
+      esbuild: '^0.25.0',
+    },
+    overrides: {
+      // Force the patched version of lodash through @vscode/vsce →
+      // @secretlint → @textlint transitive chain (4.17.23 has a
+      // code-injection advisory in `_.template`).
+      lodash: '^4.18.1',
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "4.1.19",
+  "version": "4.1.21",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry",
   "type": "module",
   "main": "dist/index.js",