miravo 0.5.0 → 0.6.1

package/src/commands/load.ts

@@ -1,167 +0,0 @@
-import { basename } from "node:path";
-import { isCancel, select } from "@clack/prompts";
-import type { ContentCatalog } from "@miravo/core";
-import { discoverTemplates } from "@miravo/core";
-import type { DiscoveredTemplate, EngineCommand } from "@miravo/shared";
-import { CONTROL_CMD_TIMEOUT_MS, ConfigNotFoundError, MiravoError } from "@miravo/shared";
-import type { Command } from "commander";
-import { executeAdminCommand, resolveAdminUrl } from "../lib/admin-client.ts";
-import { parsePositiveInt, parseTimeoutSeconds } from "../lib/parse.ts";
-import { isStressBenchmarkTemplate } from "../lib/template-category.ts";
-import {
-  createCatalog,
-  discoverPreferredLocalTemplates,
-  resolveTemplateIdentifier,
-} from "../lib/template-locator.ts";
-import { configLog, handleCommandError, handleCommandResult } from "../logger.ts";
-
-interface LoadOptions {
-  readonly template?: string;
-  readonly count?: number;
-  readonly json?: boolean;
-  readonly adminUrl?: string;
-  readonly timeout?: number;
-}
-
-export function registerLoadCommand(program: Command): void {
-  program
-    .command("load")
-    .description("Add instances from a template to the running simulation")
-    .option(
-      "-t, --template <id|name|path,...>",
-      "Template id, name, path, or comma-separated list (env: MIRAVO_TEMPLATE)",
-    )
-    .option(
-      "-c, --count <n>",
-      "Number of template copies to load per template (default: 1)",
-      parsePositiveInt,
-    )
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Miravo admin server URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo load -t smart-factory                     Load built-in template by name
-  $ miravo load -t ./extra.miravo.yaml               Load template from file
-  $ miravo load -t smart-factory,water-treatment     Load two templates at once
-  $ miravo load -t smart-factory -c 3               Load 3 copies of a template
-  $ miravo load                                      Auto-discover and load`,
-    )
-    .action(async (options: LoadOptions) => {
-      try {
-        const catalog = createCatalog();
-        const templateIdentifier = options.template ?? Bun.env["MIRAVO_TEMPLATE"];
-
-        let templatePaths: string[];
-        if (templateIdentifier !== undefined) {
-          const identifiers = templateIdentifier
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean);
-          templatePaths = await Promise.all(
-            identifiers.map((id) => resolveTemplateIdentifier(id, catalog)),
-          );
-        } else {
-          const path = await resolveLoadTemplatePath(catalog);
-          templatePaths = [path];
-        }
-
-        const adminUrl = resolveAdminUrl(options.adminUrl);
-        const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-
-        for (const templatePath of templatePaths) {
-          const command: EngineCommand = {
-            type: "loadTemplate",
-            templatePath,
-            count: options.count ?? 1,
-          };
-          const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-          handleCommandResult(result, options.json);
-        }
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-async function resolveLoadTemplatePath(catalog: ContentCatalog): Promise<string> {
-  // 1. Auto-discover local templates (CWD + local registry)
-  const discovered = await discoverPreferredLocalTemplates(catalog);
-  if (discovered.length === 1) {
-    const first = discovered[0];
-    if (first !== undefined) {
-      configLog.info(`Found template: ${first.name} (${first.path})`);
-      return first.path;
-    }
-  }
-  if (discovered.length > 1) {
-    if (!process.stdout.isTTY || !process.stdin.isTTY) {
-      const names = discovered.map((t) => t.name).join(", ");
-      throw new MiravoError(
-        `Found ${discovered.length} templates: ${names}.`,
-        "Use '--template <name|path>' to specify which template to use.",
-      );
-    }
-    const first = discovered[0];
-    if (first !== undefined) {
-      configLog.warn(
-        `Found ${discovered.length} templates: ${discovered.map((t) => t.name).join(", ")}. Using ${first.name}. Use '--template <name|path>' to specify.`,
-      );
-      return first.path;
-    }
-  }
-
-  // 2. Fall back to built-in templates
-  const builtinTemplateDir = catalog.getBuiltinTemplatesDir();
-  let builtinTemplates: readonly DiscoveredTemplate[] = [];
-  try {
-    const all = await discoverTemplates(builtinTemplateDir);
-    builtinTemplates = all.filter((t) => !isStressBenchmarkTemplate(t.id));
-  } catch {
-    // Builtin dir may not exist in edge cases
-  }
-  if (builtinTemplates.length > 0) {
-    if (process.stdout.isTTY && process.stdin.isTTY) {
-      return pickBuiltinTemplate(builtinTemplates);
-    }
-    const selected =
-      builtinTemplates.find((t) => basename(t.path) === "smart-factory.miravo.yaml") ??
-      builtinTemplates[0];
-    if (selected !== undefined) {
-      configLog.info(`No template specified. Using built-in "${selected.name}".`);
-      configLog.info(
-        "Run 'miravo templates list' to see all options, or use --template <name|path>.",
-      );
-      return selected.path;
-    }
-  }
-
-  // 3. Nothing available
-  throw new ConfigNotFoundError(
-    "No template found. Use 'miravo templates list' to find built-ins or pass 'miravo load --template <name|path>'.",
-  );
-}
-
-async function pickBuiltinTemplate(templates: readonly DiscoveredTemplate[]): Promise<string> {
-  configLog.info("No template found in current directory.\n");
-
-  const choice = await select({
-    message: "Choose a built-in template to load:",
-    options: templates.map((t) => ({
-      value: t.path,
-      label: t.name,
-      hint: t.description ?? t.id,
-    })),
-    maxItems: 9,
-  });
-
-  if (isCancel(choice)) {
-    process.exit(0);
-  }
-
-  configLog.info("Tip: use --template <id> to skip this prompt next time.");
-
-  return choice as string;
-}

package/src/commands/logs.ts

@@ -1,175 +0,0 @@
-import type { WSMessage } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import { isPidAlive, readEntry } from "../lib/daemon-registry.ts";
-import { parseNonNegativeInt } from "../lib/parse.ts";
-import { handleCommandError, writeOutput } from "../logger.ts";
-
-interface LogsOptions {
-  readonly tail?: number;
-  readonly channels?: string;
-}
-
-export function registerLogsCommand(program: Command): void {
-  program
-    .command("logs <name>")
-    .description("Stream domain events from a background simulation")
-    .option("--tail <n>", "Fetch last N events before streaming", parseNonNegativeInt)
-    .option(
-      "--channels <list>",
-      "Comma-separated channels: faults,lifecycle,instances,adapters,engine (default: all except tick)",
-    )
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo logs my-sim                     Stream live events
-  $ miravo logs my-sim --tail 50           Show last 50 events first
-  $ miravo logs my-sim --channels faults   Only fault events`,
-    )
-    .action(async (name: string, options: LogsOptions) => {
-      try {
-        await logsAction(name, options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-async function logsAction(name: string, options: LogsOptions): Promise<void> {
-  const entry = await readEntry(name);
-  if (!entry) {
-    writeOutput(`Simulation "${name}" not found. Use 'miravo ps' to list running simulations.`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (!isPidAlive(entry.pid)) {
-    writeOutput(`Simulation "${name}" is not running.`);
-    process.exitCode = 1;
-    return;
-  }
-
-  const adminUrl = `http://${entry.adminHost}:${entry.adminPort}`;
-
-  // Fetch historical events if --tail is set
-  if (options.tail !== undefined && options.tail > 0) {
-    try {
-      const response = await fetch(`${adminUrl}/events?limit=${options.tail}`, {
-        signal: AbortSignal.timeout(5_000),
-      });
-      if (response.ok) {
-        const result = (await response.json()) as { events: readonly Record<string, unknown>[] };
-        for (const event of result.events) {
-          const formatted = formatLoggedEvent(event);
-          if (formatted) writeOutput(formatted);
-        }
-      }
-    } catch {
-      writeOutput("Warning: could not fetch historical events.");
-    }
-  }
-
-  // Connect WebSocket for live streaming
-  const wsUrl = `ws://${entry.adminHost}:${entry.adminPort}/ws`;
-
-  const selectedChannels = options.channels
-    ? options.channels.split(",").map((c) => c.trim())
-    : ["faults", "lifecycle", "instances", "engine", "adapters"];
-
-  const ws = new WebSocket(wsUrl);
-  let connected = false;
-  let userInitiatedClose = false;
-
-  const cleanup = (): void => {
-    userInitiatedClose = true;
-    ws.close();
-    process.exit(0);
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-
-  ws.onopen = () => {
-    connected = true;
-    ws.send(JSON.stringify({ type: "subscribe", channels: selectedChannels }));
-    writeOutput(
-      `${colors.dim("Connected to")} ${name} ${colors.dim(`(channels: ${selectedChannels.join(", ")})`)}`,
-    );
-    writeOutput(colors.dim("Waiting for events... (Ctrl+C to stop)"));
-  };
-
-  ws.onmessage = (event) => {
-    try {
-      const msg = JSON.parse(String(event.data)) as WSMessage;
-      const formatted = formatWSEvent(msg);
-      if (formatted) writeOutput(formatted);
-    } catch {
-      // Ignore parse errors
-    }
-  };
-
-  ws.onerror = () => {
-    if (!connected) {
-      writeOutput(`Failed to connect to simulation "${name}". Is it still running?`);
-      process.exit(1);
-    }
-    writeOutput(`Connection lost to simulation "${name}".`);
-  };
-
-  // Keep alive until WebSocket closes
-  await new Promise<void>((resolve) => {
-    ws.onclose = () => resolve();
-  });
-
-  if (!connected || !userInitiatedClose) {
-    process.exit(1);
-  }
-}
-
-/** Format a WebSocket message for terminal output. Returns null for tick events. */
-export function formatWSEvent(msg: WSMessage): string | null {
-  switch (msg.type) {
-    case "fault:triggered":
-      return `${colors.red("[fault:triggered]")} ${msg.instanceId} · ${msg.fault}`;
-    case "fault:cleared":
-      return `${colors.green("[fault:cleared]")} ${msg.instanceId} · ${msg.fault}`;
-    case "lifecycle:changed":
-      return `${colors.blue("[lifecycle:changed]")} ${msg.instanceId} · ${msg.from} → ${msg.to}`;
-    case "instance:created":
-      return `${colors.cyan("[instance:created]")} ${msg.id} · ${msg.assetType}`;
-    case "instance:removed":
-      return `${colors.yellow("[instance:removed]")} ${msg.id}`;
-    case "engine:state":
-      return `${colors.magenta("[engine:state]")} ${msg.from} → ${msg.to}`;
-    case "adapter:enabled":
-      return `${colors.cyan("[adapter:enabled]")} ${msg.name}`;
-    case "adapter:disabled":
-      return `${colors.yellow("[adapter:disabled]")} ${msg.name}`;
-    case "tick":
-    case "snapshot":
-    case "resync-required":
-      return null;
-    default:
-      return null;
-  }
-}
-
-function formatLoggedEvent(event: Record<string, unknown>): string | null {
-  const type = event["type"];
-  if (typeof type !== "string") return null;
-
-  switch (type) {
-    case "fault:triggered":
-      return `${colors.red("[fault:triggered]")} ${event["instanceId"]} · ${event["fault"]}`;
-    case "fault:cleared":
-      return `${colors.green("[fault:cleared]")} ${event["instanceId"]} · ${event["fault"]}`;
-    case "lifecycle:changed":
-      return `${colors.blue("[lifecycle:changed]")} ${event["instanceId"]} · ${event["from"]} → ${event["to"]}`;
-    case "instance:created":
-      return `${colors.cyan("[instance:created]")} ${event["instanceId"]} · ${event["assetType"]}`;
-    case "instance:removed":
-      return `${colors.yellow("[instance:removed]")} ${event["instanceId"]}`;
-    default:
-      return null;
-  }
-}

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 (30):");
-    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);
-  });
-});