miravo 0.6.0 → 0.6.2

package/src/commands/models.test.ts

@@ -1,162 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { resolve } from "node:path";
-import { loadTwinModel } from "@miravo/core";
-import { type GeneratorConfig, TwinModelSchema } from "@miravo/shared";
-import { stripAnsi } from "consola/utils";
-import { configureLogger } from "../logger.ts";
-import { formatGeneratorSummary, formatModelInspect } from "./models.ts";
-
-configureLogger({ quiet: true });
-
-const modelsDir = resolve(import.meta.dir, "..", "..", "..", "content", "models");
-
-beforeEach(() => {
-  process.exitCode = 0;
-});
-
-afterEach(() => {
-  process.exitCode = 0;
-});
-
-// ---------------------------------------------------------------------------
-// formatGeneratorSummary
-// ---------------------------------------------------------------------------
-
-describe("formatGeneratorSummary", () => {
-  const cases: [string, GeneratorConfig, string][] = [
-    ["sine", { type: "sine", center: 1500, amplitude: 50, period: 60 }, "sine (center: 1500)"],
-    ["noise", { type: "noise", center: 3.5, stddev: 0.5 }, "noise (center: 3.5)"],
-    [
-      "correlated",
-      { type: "correlated", source: "rpm", factor: 0.007, offset: 2 },
-      "correlated (source: rpm)",
-    ],
-    ["random-walk", { type: "random-walk", min: 0, max: 360, step: 5 }, "random-walk (0..360)"],
-    ["step", { type: "step", values: [100, 75, 50, 75, 100], interval: 300 }, "step (5 values)"],
-    [
-      "state-machine",
-      {
-        type: "state-machine",
-        states: ["idle", "running", "cooldown"],
-        initial: "idle",
-        transitions: [{ from: "idle", to: "running" }],
-      },
-      "state-machine (3 states)",
-    ],
-    [
-      "health-dependent",
-      {
-        type: "health-dependent",
-        stages: {
-          healthy: { type: "noise", center: 1.5, stddev: 0.3 },
-          degraded: { type: "noise", center: 3.5, stddev: 0.8 },
-        },
-      },
-      "health-dependent (2 stages)",
-    ],
-    [
-      "gate",
-      {
-        type: "gate",
-        enabled_member: "run_command",
-        input: { member: "speed_command" },
-        disabled_value: 0,
-      },
-      "gate (enabled: run_command)",
-    ],
-  ];
-
-  test.each(cases)("%s → %s", (_label, config, expected) => {
-    expect(formatGeneratorSummary(config)).toBe(expected);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatModelInspect
-// ---------------------------------------------------------------------------
-
-describe("formatModelInspect", () => {
-  test("model with parameters, lifecycle, and faults shows all sections", async () => {
-    const model = await loadTwinModel(resolve(modelsDir, "centrifugal-pump.twin.yaml"));
-    const raw = formatModelInspect(
-      model,
-      resolve(modelsDir, "centrifugal-pump.twin.yaml"),
-      "built-in",
-    );
-    const output = stripAnsi(raw);
-
-    expect(output).toContain("centrifugal-pump");
-    expect(output).toContain("Parameters:");
-    expect(output).toContain("rated_rpm");
-    expect(output).toContain("Members (24):");
-    expect(output).toContain("Methods (5):");
-    expect(output).toContain("availability_state");
-    expect(output).toContain("Lifecycle: healthy");
-    expect(output).toContain("\u2192");
-    expect(output).toContain("Faults:");
-    expect(output).toContain("Source: built-in");
-  });
-
-  test("model without lifecycle shows 'none'", () => {
-    const model = TwinModelSchema.parse({
-      schema_version: "2",
-      model: { name: "test-vessel", description: "Minimal vessel" },
-      members: {
-        level: {
-          kind: "variable",
-          data_type: "Double",
-          access: "read",
-          unit: "%",
-          generator: { type: "noise", center: 65, stddev: 1.5 },
-        },
-      },
-    });
-    const raw = formatModelInspect(model, "/tmp/test-vessel.twin.yaml", "test");
-    const output = stripAnsi(raw);
-
-    expect(output).toContain("test-vessel");
-    expect(output).toContain("Methods: none");
-    expect(output).toContain("Lifecycle: none");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// CLI integration
-// ---------------------------------------------------------------------------
-
-describe("miravo models", () => {
-  test("models inspect nonexistent model sets exit code 1", async () => {
-    const { createProgram } = await import("../index.ts");
-    const program = createProgram();
-    program.exitOverride();
-
-    try {
-      await program.parseAsync(["node", "miravo", "models", "inspect", "nonexistent-model"]);
-    } catch {
-      // Commander may throw on exitOverride
-    }
-
-    expect(process.exitCode).toBe(1);
-  });
-
-  test("models list --dir with nonexistent path sets exit code 1", async () => {
-    const { createProgram } = await import("../index.ts");
-    const program = createProgram();
-    program.exitOverride();
-
-    try {
-      await program.parseAsync([
-        "node",
-        "miravo",
-        "models",
-        "list",
-        "--dir",
-        "/definitely-nonexistent-miravo-test-path",
-      ]);
-    } catch {
-      // Commander may throw on exitOverride
-    }
-
-    expect(process.exitCode).toBe(1);
-  });
-});

package/src/commands/models.ts

@@ -1,338 +0,0 @@
-import { existsSync } from "node:fs";
-import { relative, resolve } from "node:path";
-import { type DiscoveredModelWithSource, loadTwinModel } from "@miravo/core";
-import type { GeneratorConfig, TwinModel } from "@miravo/shared";
-import { TWIN_FILE_EXTENSION } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import { createCatalog } from "../lib/template-locator.ts";
-import { configLog, handleCommandError, writeOutput } from "../logger.ts";
-import { formatTable } from "../output.ts";
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-export function registerModelsCommand(program: Command): void {
-  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 .twin.yaml models")
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo models list                     List all discoverable models`,
-    )
-    .action(async (options: { readonly dir?: string }) => {
-      await modelsListAction(options);
-    });
-
-  models
-    .command("inspect <name>")
-    .description("Show detailed information about a model")
-    .option("--raw", "Dump the raw YAML file to stdout")
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo models inspect centrifugal-pump        Show model details
-  $ miravo models inspect centrifugal-pump --raw  Dump raw YAML`,
-    )
-    .action(async (name: string, options: { readonly raw?: boolean }) => {
-      await modelsInspectAction(name, options);
-    });
-}
-
-// ---------------------------------------------------------------------------
-// models list
-// ---------------------------------------------------------------------------
-
-async function modelsListAction(options: { readonly dir?: string }): Promise<void> {
-  try {
-    const catalog = createCatalog();
-    const allModels = await catalog.listModels();
-
-    const builtinModels: DiscoveredModelWithSource[] = [];
-    const localRegModels: DiscoveredModelWithSource[] = [];
-    const cwdModels: DiscoveredModelWithSource[] = [];
-
-    for (const model of allModels) {
-      switch (model.source.kind) {
-        case "builtin":
-          builtinModels.push(model);
-          break;
-        case "local":
-          localRegModels.push(model);
-          break;
-        case "cwd":
-          cwdModels.push(model);
-          break;
-        default: {
-          const _exhaustive: never = model.source.kind;
-          throw new Error(`Unexpected content source kind: ${String(_exhaustive)}`);
-        }
-      }
-    }
-
-    if (options.dir) {
-      const resolvedDir = resolve(options.dir);
-      if (!existsSync(resolvedDir)) {
-        configLog.error(`Directory not found: ${resolvedDir}`);
-        process.exitCode = 1;
-        return;
-      }
-      const { discoverModels } = await import("@miravo/core");
-      const extraModels = await discoverModels(resolvedDir);
-      const existingPaths = new Set(cwdModels.map((m) => m.path));
-      for (const extra of extraModels) {
-        if (!existingPaths.has(extra.path)) {
-          existingPaths.add(extra.path);
-          cwdModels.push({ ...extra, source: { kind: "cwd", path: resolvedDir } });
-        }
-      }
-    }
-
-    if (builtinModels.length === 0 && cwdModels.length === 0 && localRegModels.length === 0) {
-      configLog.info("No models found.");
-      return;
-    }
-
-    const headers = {
-      name: colors.dim("Name"),
-      members: colors.dim("Members"),
-      methods: colors.dim("Methods"),
-      faults: colors.dim("Faults"),
-      lifecycle: colors.dim("Lifecycle"),
-      source: colors.dim("Source"),
-    };
-
-    const renderSection = (label: string, models: readonly DiscoveredModelWithSource[]): void => {
-      if (models.length === 0) return;
-      writeOutput();
-      writeOutput(`  ${colors.bold(`${label}:`)}`);
-      writeOutput(
-        formatTable(
-          headers,
-          models.map((m) => ({
-            name: colors.cyan(m.name),
-            members: String(m.memberCount),
-            methods: String(m.methodCount),
-            faults: String(m.faultCount),
-            lifecycle:
-              m.lifecycleStageCount > 0 ? `${m.lifecycleStageCount} stages` : colors.dim("none"),
-            source: colors.dim(m.source.kind),
-          })),
-        ),
-      );
-    };
-
-    renderSection("Built-in", builtinModels);
-    renderSection("Local", localRegModels);
-    renderSection("Project", cwdModels);
-    writeOutput();
-  } catch (error) {
-    handleCommandError(error);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// models inspect
-// ---------------------------------------------------------------------------
-
-async function modelsInspectAction(
-  name: string,
-  options: { readonly raw?: boolean },
-): Promise<void> {
-  try {
-    const catalog = createCatalog();
-    const isPath = name.includes("/") || name.endsWith(TWIN_FILE_EXTENSION);
-    const resolvedPath = isPath ? resolve(name) : await catalog.resolveModel(name);
-
-    const sourceLabel = catalog.getSourceLabel(resolvedPath);
-
-    if (options.raw) {
-      const rawText = await Bun.file(resolvedPath).text();
-      process.stdout.write(rawText);
-      return;
-    }
-
-    const model = await loadTwinModel(resolvedPath);
-    const output = formatModelInspect(model, resolvedPath, sourceLabel);
-    writeOutput(output);
-  } catch (error) {
-    handleCommandError(error);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Formatting helpers (exported for testing)
-// ---------------------------------------------------------------------------
-
-export function formatGeneratorSummary(generator: GeneratorConfig): string {
-  switch (generator.type) {
-    case "sine":
-      return `sine (center: ${generator.center})`;
-    case "noise":
-      return `noise (center: ${generator.center})`;
-    case "correlated":
-      return `correlated (source: ${generator.source})`;
-    case "random-walk":
-      return `random-walk (${generator.min}..${generator.max})`;
-    case "step":
-      return `step (${generator.values.length} values)`;
-    case "state-machine":
-      return `state-machine (${generator.states.length} states)`;
-    case "health-dependent":
-      return `health-dependent (${Object.keys(generator.stages).length} stages)`;
-    case "ramp":
-      return `ramp (rate: ${generator.rate}, duration: ${generator.duration}s)`;
-    case "mean-reverting-noise":
-      return `mean-reverting-noise (mean: ${generator.mean}, tau: ${generator.tau}s)`;
-    case "timetable":
-      return `timetable (${generator.points.length} points)`;
-    case "first-order-lag":
-      return `first-order-lag (tau: ${generator.tau}s)`;
-    case "integrator":
-      return `integrator (gain: ${generator.gain})`;
-    case "transport-delay":
-      return `transport-delay (delay: ${generator.delay}s)`;
-    case "slew-rate-limiter":
-      return `slew-rate-limiter (rate_up: ${generator.rate_up})`;
-    case "second-order":
-      return `second-order (freq: ${generator.natural_freq_hz}Hz, zeta: ${generator.damping_ratio})`;
-    case "hysteresis-relay":
-      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})`;
-    case "waveform":
-      return `waveform (shape: ${generator.shape}, period: ${generator.period}s)`;
-    case "chirp":
-      return `chirp (${generator.start_freq_hz}–${generator.end_freq_hz}Hz, ${generator.sweep_duration}s)`;
-    case "impulse":
-      return `impulse (amplitude: ${generator.amplitude}${generator.probability !== undefined ? `, p=${generator.probability}` : ``})`;
-    default: {
-      const _exhaustive: never = generator;
-      return String(_exhaustive);
-    }
-  }
-}
-
-export function formatModelInspect(
-  model: TwinModel,
-  sourcePath: string,
-  sourceLabel: string,
-): string {
-  const lines: string[] = [];
-
-  // Header
-  if (model.model.description) {
-    lines.push(
-      `  ${colors.cyan(colors.bold(model.model.name))} ${colors.dim("\u2014")} ${model.model.description}`,
-    );
-  } else {
-    lines.push(`  ${colors.cyan(colors.bold(model.model.name))}`);
-  }
-  lines.push("");
-
-  // Parameters
-  if (model.parameters && Object.keys(model.parameters).length > 0) {
-    lines.push(`  ${colors.bold("Parameters:")}`);
-    lines.push(
-      formatTable(
-        {
-          name: colors.dim("Name"),
-          type: colors.dim("Type"),
-          defaultVal: colors.dim("Default"),
-          unit: colors.dim("Unit"),
-        },
-        Object.entries(model.parameters).map(([name, param]) => ({
-          name,
-          type: param.type,
-          defaultVal: String(param.default),
-          unit: param.unit ?? "",
-        })),
-      ),
-    );
-    lines.push("");
-  }
-
-  // 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"),
-      },
-      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")} `);
-    lines.push(`  ${colors.bold("Lifecycle:")} ${stageNames}`);
-  } else {
-    lines.push(`  ${colors.bold("Lifecycle:")} ${colors.dim("none")}`);
-  }
-
-  // Faults
-  if (model.faults && model.faults.length > 0) {
-    const faultNames = model.faults.map((f) => f.name).join(", ");
-    lines.push(`  ${colors.bold("Faults:")} ${faultNames}`);
-  } else {
-    lines.push(`  ${colors.bold("Faults:")} ${colors.dim("none")}`);
-  }
-
-  // Source
-  const relPath = relative(process.cwd(), sourcePath);
-  lines.push(`  ${colors.bold("Source:")} ${sourceLabel} ${colors.gray(`(${relPath})`)}`);
-
-  return lines.join("\n");
-}

package/src/commands/pause.ts

@@ -1,67 +0,0 @@
-import type { EngineCommand } from "@miravo/shared";
-import { CONTROL_CMD_TIMEOUT_MS } from "@miravo/shared";
-import type { Command } from "commander";
-import { executeAdminCommand, resolveAdminUrl } from "../lib/admin-client.ts";
-import { parseTimeoutSeconds } from "../lib/parse.ts";
-import { handleCommandError, handleCommandResult } from "../logger.ts";
-
-interface PauseResumeOptions {
-  readonly json?: boolean;
-  readonly adminUrl?: string;
-  readonly timeout?: number;
-}
-
-export function registerPauseCommand(program: Command): void {
-  program
-    .command("pause")
-    .description("Pause the running simulation (state is preserved)")
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo pause                           Pause the simulation`,
-    )
-    .action(async (options: PauseResumeOptions) => {
-      try {
-        await sendSimpleCommand("pause", options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-export function registerResumeCommand(program: Command): void {
-  program
-    .command("resume")
-    .description("Resume a paused simulation")
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo resume                          Resume a paused simulation`,
-    )
-    .action(async (options: PauseResumeOptions) => {
-      try {
-        await sendSimpleCommand("resume", options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-async function sendSimpleCommand(
-  type: "pause" | "resume",
-  options: PauseResumeOptions,
-): Promise<void> {
-  const adminUrl = resolveAdminUrl(options.adminUrl);
-  const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-  const command: EngineCommand = { type };
-  const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-  handleCommandResult(result, options.json);
-}