@tsplc/compiler 0.0.0-stage → 0.2.0

package/project/cli.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env bun
+import { buildServer } from "./server.ts";
+import { parseArgs } from "node:util";
+import { resolve } from "node:path";
+import {
+  buildTargetFor,
+  controllerFor,
+  loadTsplcConfig,
+  rawBuildConfig,
+  simulationConfig,
+} from "@tsplc/config";
+import {
+  buildProject as buildSt,
+  configureDocker,
+  configureRuntime,
+  inspectController,
+  installLibraries,
+  loadSources,
+  resolveConfig,
+  runProject,
+  updateController,
+} from "@tsplc/build";
+import { checkHostConfig } from "@tsplc/compiler";
+import { type Diagnostic, formatDiagnostic, hasErrors } from "@tsplc/compiler/ir";
+import { deviceTree } from "@tsplc/typegen";
+import { loadHardware, resolveIo } from "@tsplc/typegen/hardware";
+import { generateProject } from "@tsplc/typegen";
+import { plantCommands, runPlantCommand } from "./plant.ts";
+import { buildProject, checkProject, cleanProject, projectTargets } from "./project.ts";
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      config: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      "emit-only": { type: "boolean" },
+      format: { type: "string" },
+      read: { type: "string", multiple: true },
+      "initialize-user": { type: "boolean" },
+      "frozen-lockfile": { type: "boolean" },
+      check: { type: "boolean" },
+      plc: { type: "boolean" },
+      server: { type: "boolean" },
+      simulate: { type: "boolean" },
+      runtime: { type: "boolean" },
+      download: { type: "boolean" },
+      restore: { type: "boolean" },
+      select: { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
+    },
+  });
+  const command = positionals[0],
+    file = values.config ?? "tsplc.config.ts";
+  if (!command || values.help) {
+    console.log(
+      `tsplc install|typegen|check|build|run|download|online-change|inspect|clean|configure [--config tsplc.config.ts] [--plc|--server] [--simulate] [--runtime] [--emit-only] [--format json] [--read symbol]
+
+Plant agent (TSPLC_AGENT_URL, TSPLC_AGENT_TOKEN):
+  tsplc deploy [--download] [--select] [--initialize-user]
+  tsplc target | status | login | logout
+  tsplc vars [path] | read <expression>... | write <expression> <value>
+  tsplc force <expression> <value> | unforce [expression]... [--restore]
+  tsplc start | stop | reset warm|cold   (-y skips confirmations)`,
+    );
+    return 0;
+  }
+  if (plantCommands.has(command)) {
+    const failed = await runPlantCommand(command, positionals.slice(1), values, {
+      file,
+      load: () => loadTsplcConfig(file),
+    });
+    return failed ? report(failed, values.format) : 0;
+  }
+  if (positionals.length > 1) throw new Error("Specify one command.");
+  if (
+    ![
+      "install",
+      "typegen",
+      "check",
+      "build",
+      "run",
+      "download",
+      "online-change",
+      "inspect",
+      "clean",
+      "configure",
+    ].includes(command)
+  )
+    throw new Error(`Unknown command ${command}.`);
+  if (values.format && !["json", "text"].includes(values.format))
+    throw new Error("--format must be json or text.");
+  if (values["emit-only"] && command !== "build")
+    throw new Error("--emit-only is supported by build only.");
+  if (values.runtime && command !== "configure")
+    throw new Error("--runtime applies only to configure.");
+  if ((values.plc || values.server) && command !== "build")
+    throw new Error("--plc and --server apply only to build.");
+  if (values.simulate && !["run", "download", "online-change"].includes(command))
+    throw new Error("--simulate applies only to run, download and online-change.");
+  if (values.plc && values.server)
+    throw new Error("Choose --plc or --server, or omit both for a full build.");
+  if (values.server && values["emit-only"])
+    throw new Error("--emit-only applies to PLC emission only.");
+  const log = console.log,
+    previousLogTarget = process.env["TSPLC_LOG_STDERR"];
+  if (values.format === "json") {
+    console.log = console.error;
+    process.env["TSPLC_LOG_STDERR"] = "1";
+  }
+  let result: unknown;
+  try {
+    if (command === "configure") {
+      await (values.runtime ? configureRuntime() : configureDocker());
+      result = { ok: true };
+    } else if (command === "clean") {
+      result = await cleanProject(file);
+    } else {
+      if (["check", "build", "run", "download", "online-change"].includes(command)) {
+        const diagnostics = checkHostConfig(resolve(file));
+        if (hasErrors(diagnostics)) throw new DiagnosticFailure({ diagnostics });
+      }
+      const loaded = await loadTsplcConfig(file);
+      const { config, configFile, root } = loaded;
+      // Generated types keep describing the hardware project; only the download omits fieldbus I/O.
+      const target = values.simulate ? { ...loaded, config: simulationConfig(config) } : loaded;
+      if (command === "install")
+        result = {
+          libraries: await installLibraries(config.dependencies, root, {
+            frozen: values["frozen-lockfile"],
+          }),
+        };
+      else if (command === "typegen") {
+        const targets = await projectTargets(file, { loaded });
+        if (config.compiler && !values.check) {
+          await generateProject(file, { hardwareOnly: true, loaded, targets });
+          const emitted = await buildProject(file, { emitOnly: true, loaded });
+          if (hasErrors(emitted.diagnostics)) throw new DiagnosticFailure(emitted);
+        }
+        result = await generateProject(file, { check: values.check, loaded, targets });
+      } else if (command === "check") {
+        result = config.compiler
+          ? await checkProject(file, { loaded })
+          : {
+              objects: (
+                await loadSources(
+                  resolveConfig(
+                    {
+                      ...rawBuildConfig(config),
+                      io: resolveIo(config, await loadHardware(config, root)),
+                    },
+                    configFile,
+                  ),
+                )
+              ).objects.length,
+            };
+      } else if (command === "build" && values.server) {
+        result = await buildServer(config, root);
+      } else if (command === "build" || command === "run") {
+        if (config.compiler) {
+          const built = await buildProject(file, {
+            emitOnly: values["emit-only"],
+            frozenLockfile: values["frozen-lockfile"],
+            loaded: target,
+            controller: controllerFor(config, command),
+            buildTarget: buildTargetFor(command),
+          });
+          if (hasErrors(built.diagnostics)) throw new DiagnosticFailure(built);
+          await generateProject(file, {
+            loaded,
+            targets: await projectTargets(file, { loaded }),
+          });
+          result = built;
+        } else {
+          if (values["emit-only"]) throw new Error("Raw Structured Text is already emitted.");
+          if (!config.build) throw new Error("Configure build settings.");
+          const build = rawBuildConfig(config);
+          const libraries = await installLibraries(config.dependencies, root, {
+            frozen: values["frozen-lockfile"],
+          });
+          const hardware = await loadHardware(target.config, root);
+          result = await buildSt(
+            resolveConfig(
+              {
+                ...build,
+                libraries,
+                io: resolveIo(target.config, hardware),
+                deviceTree: await deviceTree(target.config, hardware),
+                controller: controllerFor(config, command),
+              },
+              configFile,
+            ),
+          );
+          await generateProject(file, { hardwareOnly: !config.typegen, loaded });
+        }
+        if (command === "build" && !values.plc && !values["emit-only"] && config.server?.runtime) {
+          const backend = await buildServer(config, root);
+          result = { ...(typeof result === "object" && result !== null ? result : {}), ...backend };
+        }
+        if (command === "run") {
+          if (!config.build) throw new Error("Configure build to run this project.");
+          await runProject(
+            resolveConfig(config.compiler ? config.build : rawBuildConfig(config), configFile),
+            config.name,
+          );
+        }
+      } else if (command === "inspect") {
+        if (!config.build) throw new Error("Configure build settings and controller connection.");
+        // Inspection needs only the connection/baseline. It must remain usable
+        // when local sources, descriptors or dependency caches are unavailable.
+        result = await inspectController(
+          resolveConfig(
+            { ...config.build, controller: controllerFor(config, command) },
+            configFile,
+          ),
+          values.read,
+        );
+      } else if (["download", "online-change"].includes(command)) {
+        if (!config.build) throw new Error("Configure build settings and controller connection.");
+        let settings: ReturnType<typeof resolveConfig>;
+        if (config.compiler) {
+          const emitted = await buildProject(file, {
+            emitOnly: true,
+            forController: true,
+            frozenLockfile: values["frozen-lockfile"],
+            loaded: target,
+            buildTarget: buildTargetFor(command),
+          });
+          if (hasErrors(emitted.diagnostics)) throw new DiagnosticFailure(emitted);
+          if (!emitted.controllerConfig)
+            throw new Error("Configure build settings for deployment.");
+          // Emission already resolves the generated entry/task paths. Passing
+          // this through the input schema again would reject its configFile.
+          settings = { ...emitted.controllerConfig, io: {} };
+        } else
+          settings = {
+            ...resolveConfig(
+              {
+                ...rawBuildConfig(config),
+                io: resolveIo(target.config, await loadHardware(target.config, root)),
+              },
+              configFile,
+            ),
+            libraries: await installLibraries(config.dependencies, root, {
+              frozen: values["frozen-lockfile"],
+            }),
+          };
+        result = await updateController(
+          { ...settings, controller: controllerFor(config, command) },
+          command as "download" | "online-change",
+          {
+            initializeUser: values["initialize-user"],
+            read: values.read,
+          },
+        );
+      } else throw new Error(`Unknown command ${command}.`);
+    }
+  } finally {
+    console.log = log;
+    if (previousLogTarget === undefined) delete process.env["TSPLC_LOG_STDERR"];
+    else process.env["TSPLC_LOG_STDERR"] = previousLogTarget;
+  }
+  return report(result, values.format);
+}
+class DiagnosticFailure extends Error {
+  constructor(readonly result: unknown) {
+    super("PLC validation failed.");
+  }
+}
+function report(result: unknown, format?: string) {
+  const diagnostics =
+    result && typeof result === "object" && "diagnostics" in result
+      ? (result.diagnostics as Diagnostic[])
+      : [];
+  const ok = !hasErrors(diagnostics);
+  if (format === "json")
+    console.log(
+      JSON.stringify({ ok, ...(result && typeof result === "object" ? result : { result }) }),
+    );
+  else {
+    for (const diagnostic of diagnostics) console.error(formatDiagnostic(diagnostic));
+    if (ok) console.log("tsPLC completed.");
+  }
+  return ok ? 0 : 1;
+}
+try {
+  process.exitCode = await main();
+} catch (cause) {
+  // main() may fail before its options parse, so detect JSON output from raw argv.
+  const json = process.argv.includes("json") || process.argv.includes("--format=json");
+  if (cause instanceof DiagnosticFailure) {
+    process.exitCode = report(cause.result, json ? "json" : undefined);
+  } else {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    if (json)
+      console.log(
+        JSON.stringify({
+          ok: false,
+          diagnostics: [{ origin: "config", code: "PLC5003", severity: "error", message }],
+        }),
+      );
+    else console.error(message);
+    process.exitCode = 1;
+  }
+}

package/project/index.ts

@@ -0,0 +1 @@
+export { checkProject, buildProject, cleanProject, projectTargets } from "./project.ts";