miravo 0.1.4 → 0.2.1

package/src/commands/models.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { relative, resolve } from "node:path";
 import { type DiscoveredModelWithSource, loadTwinModel } from "@miravo/core";
-import type { DigitalTwinModel, GeneratorConfig } from "@miravo/shared";
+import type { GeneratorConfig, TwinModel } from "@miravo/shared";
 import { TWIN_FILE_EXTENSION } from "@miravo/shared";
 import type { Command } from "commander";
 import { colors } from "consola/utils";
@@ -14,17 +14,13 @@ import { formatTable } from "../output.ts";
 // ---------------------------------------------------------------------------
 
 export function registerModelsCommand(program: Command): void {
-  const models = program.command("models").description("List and inspect digital twin models");
+  const models = program.command("models").description("List and inspect asset models");
 
   models
     .command("list")
     .description("Discover and list available models")
     .option("--dir <path>", "Additional directory to search for models")
-    .option(
-      "--content-dir <path>",
-      "User content root with /templates and /models (env: MIRAVO_CONTENT_DIR)",
-    )
-    .action(async (options: { readonly dir?: string; readonly contentDir?: string }) => {
+    .action(async (options: { readonly dir?: string }) => {
       await modelsListAction(options);
     });
 
@@ -32,43 +28,34 @@ export function registerModelsCommand(program: Command): void {
     .command("inspect <name>")
     .description("Show detailed information about a model")
     .option("--raw", "Dump the raw YAML file to stdout")
-    .option(
-      "--content-dir <path>",
-      "User content root with /templates and /models (env: MIRAVO_CONTENT_DIR)",
-    )
-    .action(
-      async (name: string, options: { readonly raw?: boolean; readonly contentDir?: string }) => {
-        await modelsInspectAction(name, options);
-      },
-    );
+    .action(async (name: string, options: { readonly raw?: boolean }) => {
+      await modelsInspectAction(name, options);
+    });
 }
 
 // ---------------------------------------------------------------------------
 // models list
 // ---------------------------------------------------------------------------
 
-async function modelsListAction(options: {
-  readonly dir?: string;
-  readonly contentDir?: string;
-}): Promise<void> {
+async function modelsListAction(options: { readonly dir?: string }): Promise<void> {
   try {
-    const catalog = createCatalog(options.contentDir);
+    const catalog = createCatalog();
     const allModels = await catalog.listModels();
 
     const builtinModels: DiscoveredModelWithSource[] = [];
-    const contentDirModels: DiscoveredModelWithSource[] = [];
-    const localModels: DiscoveredModelWithSource[] = [];
+    const localRegModels: DiscoveredModelWithSource[] = [];
+    const cwdModels: DiscoveredModelWithSource[] = [];
 
     for (const model of allModels) {
       switch (model.source.kind) {
         case "builtin":
           builtinModels.push(model);
           break;
-        case "content-dir":
-          contentDirModels.push(model);
+        case "local":
+          localRegModels.push(model);
           break;
         case "cwd":
-          localModels.push(model);
+          cwdModels.push(model);
           break;
         default: {
           const _exhaustive: never = model.source.kind;
@@ -85,23 +72,24 @@ async function modelsListAction(options: {
       }
       const { discoverModels } = await import("@miravo/core");
       const extraModels = await discoverModels(resolvedDir);
-      const existingPaths = new Set(localModels.map((m) => m.path));
+      const existingPaths = new Set(cwdModels.map((m) => m.path));
       for (const extra of extraModels) {
         if (!existingPaths.has(extra.path)) {
           existingPaths.add(extra.path);
-          localModels.push({ ...extra, source: { kind: "cwd", path: resolvedDir } });
+          cwdModels.push({ ...extra, source: { kind: "cwd", path: resolvedDir } });
         }
       }
     }
 
-    if (builtinModels.length === 0 && localModels.length === 0 && contentDirModels.length === 0) {
+    if (builtinModels.length === 0 && cwdModels.length === 0 && localRegModels.length === 0) {
       configLog.info("No models found.");
       return;
     }
 
     const headers = {
       name: colors.dim("Name"),
-      sensors: colors.dim("Sensors"),
+      members: colors.dim("Members"),
+      methods: colors.dim("Methods"),
       faults: colors.dim("Faults"),
       lifecycle: colors.dim("Lifecycle"),
       source: colors.dim("Source"),
@@ -116,7 +104,8 @@ async function modelsListAction(options: {
           headers,
           models.map((m) => ({
             name: colors.cyan(m.name),
-            sensors: String(m.sensorCount),
+            members: String(m.memberCount),
+            methods: String(m.methodCount),
             faults: String(m.faultCount),
             lifecycle:
               m.lifecycleStageCount > 0 ? `${m.lifecycleStageCount} stages` : colors.dim("none"),
@@ -127,8 +116,8 @@ async function modelsListAction(options: {
     };
 
     renderSection("Built-in", builtinModels);
-    renderSection("Content Directory", contentDirModels);
-    renderSection("Local", localModels);
+    renderSection("Local", localRegModels);
+    renderSection("Project", cwdModels);
     writeOutput();
   } catch (error) {
     handleCommandError(error);
@@ -141,10 +130,10 @@ async function modelsListAction(options: {
 
 async function modelsInspectAction(
   name: string,
-  options: { readonly raw?: boolean; readonly contentDir?: string },
+  options: { readonly raw?: boolean },
 ): Promise<void> {
   try {
-    const catalog = createCatalog(options.contentDir);
+    const catalog = createCatalog();
     const isPath = name.includes("/") || name.endsWith(TWIN_FILE_EXTENSION);
     const resolvedPath = isPath ? resolve(name) : await catalog.resolveModel(name);
 
@@ -204,6 +193,8 @@ export function formatGeneratorSummary(generator: GeneratorConfig): string {
       return `hysteresis-relay (on: ${generator.on_threshold}, off: ${generator.off_threshold})`;
     case "weighted-sum":
       return `weighted-sum (${generator.terms.length} terms)`;
+    case "gate":
+      return `gate (enabled: ${generator.enabled_member})`;
     default: {
       const _exhaustive: never = generator;
       return String(_exhaustive);
@@ -212,19 +203,19 @@ export function formatGeneratorSummary(generator: GeneratorConfig): string {
 }
 
 export function formatModelInspect(
-  model: DigitalTwinModel,
+  model: TwinModel,
   sourcePath: string,
   sourceLabel: string,
 ): string {
   const lines: string[] = [];
 
   // Header
-  if (model.description) {
+  if (model.model.description) {
     lines.push(
-      `  ${colors.cyan(colors.bold(model.name))} ${colors.dim("\u2014")} ${model.description}`,
+      `  ${colors.cyan(colors.bold(model.model.name))} ${colors.dim("\u2014")} ${model.model.description}`,
     );
   } else {
-    lines.push(`  ${colors.cyan(colors.bold(model.name))}`);
+    lines.push(`  ${colors.cyan(colors.bold(model.model.name))}`);
   }
   lines.push("");
 
@@ -250,24 +241,59 @@ export function formatModelInspect(
     lines.push("");
   }
 
-  // Sensors
-  lines.push(`  ${colors.bold(`Sensors (${model.sensors.length}):`)}`);
+  // Members
+  const memberEntries = Object.entries(model.members) as Array<
+    [string, TwinModel["members"][string]]
+  >;
+  lines.push(`  ${colors.bold(`Members (${memberEntries.length}):`)}`);
   lines.push(
     formatTable(
       {
         name: colors.dim("Name"),
+        kind: colors.dim("Kind"),
+        dataType: colors.dim("Data Type"),
         unit: colors.dim("Unit"),
         generator: colors.dim("Generator"),
       },
-      model.sensors.map((s) => ({
-        name: s.name,
-        unit: s.unit,
-        generator: formatGeneratorSummary(s.generator),
+      memberEntries.map(([name, member]) => ({
+        name,
+        kind: member.kind,
+        dataType: member.data_type,
+        unit: member.unit ?? "",
+        generator:
+          member.kind === "variable" && member.generator
+            ? formatGeneratorSummary(member.generator)
+            : colors.dim("none"),
       })),
     ),
   );
   lines.push("");
 
+  const methodEntries = Object.entries(model.methods ?? {});
+  if (methodEntries.length > 0) {
+    lines.push(`  ${colors.bold(`Methods (${methodEntries.length}):`)}`);
+    lines.push(
+      formatTable(
+        {
+          name: colors.dim("Name"),
+          inputs: colors.dim("Inputs"),
+          outputs: colors.dim("Outputs"),
+          description: colors.dim("Description"),
+        },
+        methodEntries.map(([name, method]) => ({
+          name,
+          inputs: String(Object.keys(method.input_arguments ?? {}).length),
+          outputs: String(Object.keys(method.output_arguments ?? {}).length),
+          description: method.description ?? "",
+        })),
+      ),
+    );
+    lines.push("");
+  } else {
+    lines.push(`  ${colors.bold("Methods:")} ${colors.dim("none")}`);
+    lines.push("");
+  }
+
   // Lifecycle
   if (model.lifecycle && model.lifecycle.stages.length > 0) {
     const stageNames = model.lifecycle.stages.map((s) => s.name).join(` ${colors.dim("\u2192")} `);

package/src/commands/start.test.ts

@@ -1,5 +1,4 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import { createTmpFileUtils } from "@miravo/core/test-tmp-utils";
 import type { DiscoveredTemplate, MiravoTemplate } from "@miravo/shared";
@@ -8,15 +7,27 @@ import { resetExitCode, runCliCommand, withEnvVar } from "./cli-test-setup.ts";
 const { writeTmpFile, cleanupTmpDir } = createTmpFileUtils(
   resolve(import.meta.dir, ".tmp-test-start"),
 );
-const builtinTemplatesDir = resolve(import.meta.dir, "..", "..", "..", "..", "templates");
+const builtinTemplatesDir = resolve(import.meta.dir, "..", "..", "..", "content", "templates");
+const stressTemplatesDir = resolve(
+  import.meta.dir,
+  "..",
+  "..",
+  "..",
+  "..",
+  "tests",
+  "fixtures",
+  "stress",
+);
 const BUILTIN_TEMPLATE_PATHS = [
   resolve(builtinTemplatesDir, "smart-factory.miravo.yaml"),
   resolve(builtinTemplatesDir, "water-treatment.miravo.yaml"),
   resolve(builtinTemplatesDir, "commercial-building.miravo.yaml"),
   resolve(builtinTemplatesDir, "backup-power.miravo.yaml"),
-  resolve(builtinTemplatesDir, "stress-10k-uns.miravo.yaml"),
-  resolve(builtinTemplatesDir, "stress-50k-uns.miravo.yaml"),
-  resolve(builtinTemplatesDir, "stress-100k-uns.miravo.yaml"),
+  resolve(stressTemplatesDir, "stress-5k.miravo.yaml"),
+  resolve(stressTemplatesDir, "stress-10k.miravo.yaml"),
+  resolve(stressTemplatesDir, "stress-50k.miravo.yaml"),
+  resolve(stressTemplatesDir, "stress-100k.miravo.yaml"),
+  resolve(stressTemplatesDir, "stress-200k.miravo.yaml"),
 ];
 
 beforeEach(resetExitCode);
@@ -25,10 +36,15 @@ afterEach(async () => {
   await cleanupTmpDir();
 });
 
-const MINIMAL_MODEL = `name: test-sensor
-sensors:
-  - name: temperature
-    unit: celsius
+const MINIMAL_MODEL = `schema_version: "2"
+model:
+  name: test-sensor
+members:
+  temperature:
+    kind: variable
+    data_type: Double
+    access: read
+    unit: degC
     generator:
       type: noise
       center: 25
@@ -61,17 +77,6 @@ function discoveredTemplate(id: string, name: string, description?: string): Dis
   };
 }
 
-async function setupContentDir(subdir: string, templateFileName: string) {
-  const contentRoot = resolve(import.meta.dir, ".tmp-test-start", subdir);
-  const contentModelsDir = resolve(contentRoot, "models");
-  const contentTemplatesDir = resolve(contentRoot, "templates");
-  await mkdir(contentModelsDir, { recursive: true });
-  await mkdir(contentTemplatesDir, { recursive: true });
-  await Bun.write(resolve(contentModelsDir, "test-sensor.twin.yaml"), MINIMAL_MODEL);
-  await Bun.write(resolve(contentTemplatesDir, templateFileName), MINIMAL_TEMPLATE("test-sensor"));
-  return contentRoot;
-}
-
 describe("miravo start", () => {
   // We test the internal logic by importing the createProgram and
   // using Commander's parseAsync with exitOverride to prevent process.exit
@@ -101,42 +106,6 @@ describe("miravo start", () => {
     expect(process.exitCode).toBe(0);
   });
 
-  test("--template resolves by ID from --content-dir templates", async () => {
-    const contentRoot = await setupContentDir(
-      "content-id-resolution",
-      "factory-template.miravo.yaml",
-    );
-
-    await runCliCommand([
-      "start",
-      "--template",
-      "factory-template",
-      "--content-dir",
-      contentRoot,
-      "--name",
-      "test-sim",
-      "--dry-run",
-    ]);
-
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("--template prefers user content over built-in template IDs", async () => {
-    const contentRoot = await setupContentDir("content-precedence", "smart-factory.miravo.yaml");
-
-    await runCliCommand([
-      "start",
-      "--template",
-      "smart-factory",
-      "--content-dir",
-      contentRoot,
-      "--dry-run",
-    ]);
-
-    // User template lacks namespace; if built-in won precedence this would be 0.
-    expect(process.exitCode).toBe(1);
-  });
-
   test("invalid template YAML sets exit code 1", async () => {
     const templatePath = await writeTmpFile("bad.miravo.yaml", "not: valid: yaml: [");
     await runCliCommand(["start", "--template", templatePath]);
@@ -150,8 +119,8 @@ describe("miravo start", () => {
     });
   });
 
-  test("invalid MIRAVO_HEALTH_PORT env var sets exit code 1", async () => {
-    await withEnvVar("MIRAVO_HEALTH_PORT", "NaN", async () => {
+  test("invalid MIRAVO_ADMIN_PORT env var sets exit code 1", async () => {
+    await withEnvVar("MIRAVO_ADMIN_PORT", "NaN", async () => {
       await runCliCommand(["start", "--dry-run"]);
       expect(process.exitCode).toBe(1);
     });
@@ -271,14 +240,14 @@ describe("template picker choices", () => {
   test("buildBuiltinTemplateChoices renders tree labels directly in select options", async () => {
     const { buildBuiltinTemplateChoices } = await import("./start.ts");
     const choices = buildBuiltinTemplateChoices([
-      discoveredTemplate("stress-50k-uns", "Stress Benchmark 50K UNS"),
+      discoveredTemplate("stress-50k", "Stress Benchmark 50K"),
       discoveredTemplate("water-treatment", "Water Treatment Plant"),
       discoveredTemplate(
         "smart-factory",
         "Smart Factory Production Line",
         "Discrete manufacturing line",
       ),
-      discoveredTemplate("stress-10k-uns", "Stress Benchmark 10K UNS"),
+      discoveredTemplate("stress-10k", "Stress Benchmark 10K"),
     ]);
 
     expect(choices.map((choice) => choice.label)).toEqual([
@@ -286,12 +255,12 @@ describe("template picker choices", () => {
       "  \u251C\u2500 Smart Factory Production Line",
       "  \u2514\u2500 Water Treatment Plant",
       "Stress & Benchmark",
-      "  \u251C\u2500 Stress Benchmark 10K UNS",
-      "  \u2514\u2500 Stress Benchmark 50K UNS",
+      "  \u251C\u2500 Stress Benchmark 10K",
+      "  \u2514\u2500 Stress Benchmark 50K",
     ]);
     expect(choices[0]?.disabled).toBe(true);
     expect(choices[1]?.disabled).toBeUndefined();
     expect(choices[1]?.hint).toContain("Discrete manufacturing line");
-    expect(choices[4]?.hint).toContain("stress-10k-uns");
+    expect(choices[4]?.hint).toContain("stress-10k");
   });
 });