semantifold 0.9.0 → 0.11.0

package/build/src/project-cli.js

@@ -0,0 +1,145 @@
+// @ts-check
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { ProjectBuilder } from "./project-build.js";
+import { ProjectBuildReporter } from "./project-reporter.js";
+import { ProjectWatchCoordinator } from "./project-watch.js";
+import { ProjectWatchReporter } from "./project-watch-reporter.js";
+/**
+ * Owns one strict command invocation while delegating durable build behavior.
+ */
+export class SemantifoldCli {
+    /** @type {ProjectBuilder} */
+    #builder;
+    /** @type {ProjectWatchCoordinator} */
+    #coordinator;
+    /** @type {import("./project-reporter.js").WritableOutput} */
+    #stdout;
+    /** @type {import("./project-reporter.js").WritableOutput} */
+    #stderr;
+    /**
+     * Creates an importable CLI lifecycle.
+     * @param {{builder?: ProjectBuilder, coordinator?: ProjectWatchCoordinator, stderr?: import("./project-reporter.js").WritableOutput, stdout?: import("./project-reporter.js").WritableOutput}} [options] - Collaborators and sinks.
+     */
+    constructor(options = {}) {
+        this.#builder = options.builder ?? new ProjectBuilder();
+        this.#coordinator = options.coordinator ?? new ProjectWatchCoordinator({ builder: this.#builder });
+        this.#stdout = options.stdout ?? process.stdout;
+        this.#stderr = options.stderr ?? process.stderr;
+    }
+    /**
+     * Runs one command without mutating process exit state.
+     * @param {readonly string[]} arguments_ - Arguments after the executable name.
+     * @returns {Promise<0 | 1>} Exact process status.
+     */
+    async run(arguments_) {
+        const hintedFormat = arguments_.includes("--ndjson") ? "ndjson" : "human";
+        const watchHint = arguments_[0] == "watch";
+        let reporter = watchHint
+            ? new ProjectWatchReporter({ format: hintedFormat, stderr: this.#stderr, stdout: this.#stdout })
+            : new ProjectBuildReporter({ format: hintedFormat, stderr: this.#stderr, stdout: this.#stdout });
+        try {
+            const options = parseSemantifoldCliArguments(arguments_);
+            const command = "command" in options ? options.command : "build";
+            if (options.format != hintedFormat) {
+                reporter = command == "watch"
+                    ? new ProjectWatchReporter({ format: options.format, stderr: this.#stderr, stdout: this.#stdout })
+                    : new ProjectBuildReporter({ format: options.format, stderr: this.#stderr, stdout: this.#stdout });
+            }
+            if (command == "watch") {
+                const result = await this.#coordinator.run(options.projectPath, /** @type {ProjectWatchReporter} */ (reporter), {
+                    check: options.check
+                });
+                return result.status == "stopped" ? 0 : 1;
+            }
+            const controller = new AbortController();
+            const forwardSignal = () => controller.abort("Semantifold CLI received a termination signal.");
+            if (options.check) {
+                process.once("SIGINT", forwardSignal);
+                process.once("SIGTERM", forwardSignal);
+            }
+            let result;
+            try {
+                result = await this.#builder.build(options.projectPath, /** @type {ProjectBuildReporter} */ (reporter), {
+                    check: options.check,
+                    ...(options.check ? { signal: controller.signal } : {})
+                });
+            }
+            finally {
+                if (options.check) {
+                    process.removeListener("SIGINT", forwardSignal);
+                    process.removeListener("SIGTERM", forwardSignal);
+                }
+            }
+            /** @type {ProjectBuildReporter} */ (reporter).succeeded(result);
+            return 0;
+        }
+        catch (error) {
+            if (reporter instanceof ProjectWatchReporter)
+                reporter.watchFailed(error);
+            else
+                reporter.failed(error);
+            return 1;
+        }
+    }
+}
+/**
+ * Parses the intentionally narrow one-shot CLI grammar.
+ * @param {readonly string[]} arguments_ - Arguments after the executable name.
+ * @returns {Readonly<{check: boolean, format: "human" | "ndjson", projectPath: string}> | Readonly<{command: "watch", check: boolean, format: "human" | "ndjson", projectPath: string}>} Validated command options.
+ */
+export function parseSemantifoldCliArguments(arguments_) {
+    if (!Array.isArray(arguments_) || arguments_.length == 0 || arguments_[0] != "build" && arguments_[0] != "watch") {
+        invalidArguments("Expected the command 'semantifold build' or 'semantifold watch'.");
+    }
+    const command = /** @type {"build" | "watch"} */ (arguments_[0]);
+    let format = /** @type {"human" | "ndjson"} */ ("human");
+    let projectPath = "./semantifold.json";
+    let projectSeen = false;
+    let ndjsonSeen = false;
+    let checkSeen = false;
+    for (let index = 1; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument == "--check") {
+            if (checkSeen)
+                invalidArguments("Option '--check' may be supplied only once.");
+            checkSeen = true;
+            continue;
+        }
+        if (argument == "--ndjson") {
+            if (ndjsonSeen)
+                invalidArguments("Option '--ndjson' may be supplied only once.");
+            ndjsonSeen = true;
+            format = "ndjson";
+            continue;
+        }
+        if (argument == "--project") {
+            if (projectSeen)
+                invalidArguments("Option '--project' may be supplied only once.");
+            const value = arguments_[index + 1];
+            if (typeof value != "string" || value.length == 0 || value.startsWith("--")) {
+                invalidArguments("Option '--project' requires one path value.");
+            }
+            projectSeen = true;
+            projectPath = value;
+            index += 1;
+            continue;
+        }
+        invalidArguments(`Unknown command argument '${argument}'.`);
+    }
+    return command == "watch"
+        ? Object.freeze({ command, check: checkSeen, format, projectPath })
+        : Object.freeze({ check: checkSeen, format, projectPath });
+}
+/**
+ * Throws one stable CLI grammar diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidArguments(message) {
+    throw new SemantifoldDiagnostic({
+        code: "INVALID_CLI_ARGUMENTS",
+        language: "cli",
+        message
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-cli.js","sourceRoot":"","sources":["../../src/project-cli.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {ProjectBuilder} from \"./project-build.js\"\nimport {ProjectBuildReporter} from \"./project-reporter.js\"\nimport {ProjectWatchCoordinator} from \"./project-watch.js\"\nimport {ProjectWatchReporter} from \"./project-watch-reporter.js\"\n\n/**\n * Owns one strict command invocation while delegating durable build behavior.\n */\nexport class SemantifoldCli {\n  /** @type {ProjectBuilder} */\n  #builder\n  /** @type {ProjectWatchCoordinator} */\n  #coordinator\n  /** @type {import(\"./project-reporter.js\").WritableOutput} */\n  #stdout\n  /** @type {import(\"./project-reporter.js\").WritableOutput} */\n  #stderr\n\n  /**\n   * Creates an importable CLI lifecycle.\n   * @param {{builder?: ProjectBuilder, coordinator?: ProjectWatchCoordinator, stderr?: import(\"./project-reporter.js\").WritableOutput, stdout?: import(\"./project-reporter.js\").WritableOutput}} [options] - Collaborators and sinks.\n   */\n  constructor(options = {}) {\n    this.#builder = options.builder ?? new ProjectBuilder()\n    this.#coordinator = options.coordinator ?? new ProjectWatchCoordinator({builder: this.#builder})\n    this.#stdout = options.stdout ?? process.stdout\n    this.#stderr = options.stderr ?? process.stderr\n  }\n\n  /**\n   * Runs one command without mutating process exit state.\n   * @param {readonly string[]} arguments_ - Arguments after the executable name.\n   * @returns {Promise<0 | 1>} Exact process status.\n   */\n  async run(arguments_) {\n    const hintedFormat = arguments_.includes(\"--ndjson\") ? \"ndjson\" : \"human\"\n    const watchHint = arguments_[0] == \"watch\"\n    let reporter = watchHint\n      ? new ProjectWatchReporter({format: hintedFormat, stderr: this.#stderr, stdout: this.#stdout})\n      : new ProjectBuildReporter({format: hintedFormat, stderr: this.#stderr, stdout: this.#stdout})\n\n    try {\n      const options = parseSemantifoldCliArguments(arguments_)\n      const command = \"command\" in options ? options.command : \"build\"\n\n      if (options.format != hintedFormat) {\n        reporter = command == \"watch\"\n          ? new ProjectWatchReporter({format: options.format, stderr: this.#stderr, stdout: this.#stdout})\n          : new ProjectBuildReporter({format: options.format, stderr: this.#stderr, stdout: this.#stdout})\n      }\n      if (command == \"watch\") {\n        const result = await this.#coordinator.run(options.projectPath, /** @type {ProjectWatchReporter} */ (reporter), {\n          check: options.check\n        })\n\n        return result.status == \"stopped\" ? 0 : 1\n      }\n      const controller = new AbortController()\n      const forwardSignal = () => controller.abort(\"Semantifold CLI received a termination signal.\")\n\n      if (options.check) {\n        process.once(\"SIGINT\", forwardSignal)\n        process.once(\"SIGTERM\", forwardSignal)\n      }\n      let result\n\n      try {\n        result = await this.#builder.build(options.projectPath, /** @type {ProjectBuildReporter} */ (reporter), {\n          check: options.check,\n          ...(options.check ? {signal: controller.signal} : {})\n        })\n      } finally {\n        if (options.check) {\n          process.removeListener(\"SIGINT\", forwardSignal)\n          process.removeListener(\"SIGTERM\", forwardSignal)\n        }\n      }\n\n      /** @type {ProjectBuildReporter} */ (reporter).succeeded(result)\n\n      return 0\n    } catch (error) {\n      if (reporter instanceof ProjectWatchReporter) reporter.watchFailed(error)\n      else reporter.failed(error)\n\n      return 1\n    }\n  }\n}\n\n/**\n * Parses the intentionally narrow one-shot CLI grammar.\n * @param {readonly string[]} arguments_ - Arguments after the executable name.\n * @returns {Readonly<{check: boolean, format: \"human\" | \"ndjson\", projectPath: string}> | Readonly<{command: \"watch\", check: boolean, format: \"human\" | \"ndjson\", projectPath: string}>} Validated command options.\n */\nexport function parseSemantifoldCliArguments(arguments_) {\n  if (!Array.isArray(arguments_) || arguments_.length == 0 || arguments_[0] != \"build\" && arguments_[0] != \"watch\") {\n    invalidArguments(\"Expected the command 'semantifold build' or 'semantifold watch'.\")\n  }\n  const command = /** @type {\"build\" | \"watch\"} */ (arguments_[0])\n  let format = /** @type {\"human\" | \"ndjson\"} */ (\"human\")\n  let projectPath = \"./semantifold.json\"\n  let projectSeen = false\n  let ndjsonSeen = false\n  let checkSeen = false\n\n  for (let index = 1; index < arguments_.length; index += 1) {\n    const argument = arguments_[index]\n\n    if (argument == \"--check\") {\n      if (checkSeen) invalidArguments(\"Option '--check' may be supplied only once.\")\n      checkSeen = true\n      continue\n    }\n    if (argument == \"--ndjson\") {\n      if (ndjsonSeen) invalidArguments(\"Option '--ndjson' may be supplied only once.\")\n      ndjsonSeen = true\n      format = \"ndjson\"\n      continue\n    }\n    if (argument == \"--project\") {\n      if (projectSeen) invalidArguments(\"Option '--project' may be supplied only once.\")\n      const value = arguments_[index + 1]\n\n      if (typeof value != \"string\" || value.length == 0 || value.startsWith(\"--\")) {\n        invalidArguments(\"Option '--project' requires one path value.\")\n      }\n      projectSeen = true\n      projectPath = value\n      index += 1\n      continue\n    }\n    invalidArguments(`Unknown command argument '${argument}'.`)\n  }\n\n  return command == \"watch\"\n    ? Object.freeze({command, check: checkSeen, format, projectPath})\n    : Object.freeze({check: checkSeen, format, projectPath})\n}\n\n/**\n * Throws one stable CLI grammar diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidArguments(message) {\n  throw new SemantifoldDiagnostic({\n    code: \"INVALID_CLI_ARGUMENTS\",\n    language: \"cli\",\n    message\n  })\n}\n"]}

package/build/src/project-manifest.d.ts

@@ -0,0 +1,148 @@
+/**
+ * One validated immutable Semantifold project request.
+ */
+export declare class SemantifoldProject {
+    entryModule: string;
+    id: string;
+    manifestPath: string;
+    manifestText: string;
+    projectRoot: string;
+    publicationRoot: string;
+    sources: readonly Readonly<{
+        absolutePath: string;
+        entry: boolean;
+        id: string;
+        language: import("./semantic/types.js").SemanticLanguage;
+        path: string;
+    }>[];
+    targets: readonly Readonly<{
+        buildProjection: string;
+        id: string;
+        language: import("./semantic/types.js").BackendLanguage;
+        role: import("./semantic/types.js").PublicationTargetRole;
+        sourceProjection: string;
+    }>[];
+    version: 1;
+    /**
+     * Constructs a trusted normalized project value for the manifest loader.
+     * @param {NormalizedProject} value - Validated normalized fields.
+     */
+    constructor(value: NormalizedProject);
+}
+/**
+ * Loads and validates the strict versioned project-manifest boundary.
+ */
+export declare class ProjectManifestLoader {
+    /**
+     * Loads one project manifest without reading source content.
+     * @param {string} [projectPath] - Manifest path, relative to the process working directory or absolute.
+     * @returns {Promise<SemantifoldProject>} Immutable normalized project.
+     */
+    load(projectPath?: string): Promise<SemantifoldProject>;
+}
+export type NormalizedProjectSource = {
+    /**
+     * - Canonical project-absolute file path.
+     */
+    absolutePath: string;
+    /**
+     * - Whether this is the sole entry module.
+     */
+    entry: boolean;
+    /**
+     * - Stable semantic module identity.
+     */
+    id: string;
+    /**
+     * - Registered source language.
+     */
+    language: import("./semantic/types.js").SemanticLanguage;
+    /**
+     * - Canonical project-relative file path.
+     */
+    path: string;
+};
+export type NormalizedProjectTarget = {
+    /**
+     * - Generation-relative reserved build projection.
+     */
+    buildProjection: string;
+    /**
+     * - Stable project target identity.
+     */
+    id: string;
+    /**
+     * - Registered target identity.
+     */
+    language: import("./semantic/types.js").BackendLanguage;
+    /**
+     * - Explicit target role.
+     */
+    role: import("./semantic/types.js").PublicationTargetRole;
+    /**
+     * - Generation-relative generated-source projection.
+     */
+    sourceProjection: string;
+};
+export type NormalizedProject = {
+    /**
+     * - Sole entry module identity.
+     */
+    entryModule: string;
+    /**
+     * - Stable project identity.
+     */
+    id: string;
+    /**
+     * - Canonical absolute manifest path.
+     */
+    manifestPath: string;
+    /**
+     * - Exact validated manifest text.
+     */
+    manifestText: string;
+    /**
+     * - Canonical absolute project root.
+     */
+    projectRoot: string;
+    /**
+     * - Canonical absolute publication root.
+     */
+    publicationRoot: string;
+    /**
+     * - Ordered normalized sources.
+     */
+    sources: NormalizedProjectSource[];
+    /**
+     * - Ordered normalized targets.
+     */
+    targets: NormalizedProjectTarget[];
+};
+/**
+ * @typedef NormalizedProjectSource
+ * @property {string} absolutePath - Canonical project-absolute file path.
+ * @property {boolean} entry - Whether this is the sole entry module.
+ * @property {string} id - Stable semantic module identity.
+ * @property {import("./semantic/types.js").SemanticLanguage} language - Registered source language.
+ * @property {string} path - Canonical project-relative file path.
+ */
+/**
+ * @typedef NormalizedProjectTarget
+ * @property {string} buildProjection - Generation-relative reserved build projection.
+ * @property {string} id - Stable project target identity.
+ * @property {import("./semantic/types.js").BackendLanguage} language - Registered target identity.
+ * @property {import("./semantic/types.js").PublicationTargetRole} role - Explicit target role.
+ * @property {string} sourceProjection - Generation-relative generated-source projection.
+ */
+/**
+ * @typedef NormalizedProject
+ * @property {string} entryModule - Sole entry module identity.
+ * @property {string} id - Stable project identity.
+ * @property {string} manifestPath - Canonical absolute manifest path.
+ * @property {string} manifestText - Exact validated manifest text.
+ * @property {string} projectRoot - Canonical absolute project root.
+ * @property {string} publicationRoot - Canonical absolute publication root.
+ * @property {NormalizedProjectSource[]} sources - Ordered normalized sources.
+ * @property {NormalizedProjectTarget[]} targets - Ordered normalized targets.
+ */
+//# sourceMappingURL=project-manifest.d.ts.map

package/build/src/project-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-manifest.d.ts","sourceRoot":"","sources":["../../src/project-manifest.js"],"names":[],"mappings":"AA4BA;;GAEG;AACH,qBAAa,kBAAkB;IAMtB,WAAW;IACX,EAAE;IACF,YAAY;IACZ,YAAY;IACZ,WAAW;IACX,eAAe;IACf,OAAO;sBAyZF,MAAM;eACN,OAAO;YACP,MAAM;kBACN,OAAO,qBAAqB,EAAE,gBAAgB;cAC9C,MAAM;;IA5ZX,OAAO;yBAiaF,MAAM;YACN,MAAM;kBACN,OAAO,qBAAqB,EAAE,eAAe;cAC7C,OAAO,qBAAqB,EAAE,qBAAqB;0BACnD,MAAM;;IApaX,OAAO;IAbd;;;OAGG;IACH,YAAY,KAAK,EAFN,iBAEM,EAWhB;CACF;AAED;;GAEG;AACH,qBAAa,qBAAqB;IAChC;;;;OAIG;IACG,IAAI,CAAC,WAAW,AAHnB,CACA,EADQ,MAGkC,GAFhC,OAAO,CAAC,kBAAkB,CAAC,CAkCvC;CACF;AAuWE,YAAS,uBAAuB,GAChC;;;;IAAmB,YAAY,EAApB,MAAM,CACjB;;;;IAAoB,KAAK,EAAd,OAAO,CAClB;;;;IAAmB,EAAE,EAAV,MAAM,CACjB;;;;IAA2D,QAAQ,EAAxD,OAAO,qBAAqB,EAAE,gBAAgB,CACzD;;;;IAAmB,IAAI,EAAZ,MAAM,CACnB;CAAA,CAAA;AAGE,YAAS,uBAAuB,GAChC;;;;IAAmB,eAAe,EAAvB,MAAM,CACjB;;;;IAAmB,EAAE,EAAV,MAAM,CACjB;;;;IAA0D,QAAQ,EAAvD,OAAO,qBAAqB,EAAE,eAAe,CACxD;;;;IAAgE,IAAI,EAAzD,OAAO,qBAAqB,EAAE,qBAAqB,CAC9D;;;;IAAmB,gBAAgB,EAAxB,MAAM,CACnB;CAAA,CAAA;AAGE,YAAS,iBAAiB,GAC1B;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAmB,EAAE,EAAV,MAAM,CACjB;;;;IAAmB,YAAY,EAApB,MAAM,CACjB;;;;IAAmB,YAAY,EAApB,MAAM,CACjB;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAmB,eAAe,EAAvB,MAAM,CACjB;;;;IAAsC,OAAO,EAAlC,uBAAuB,EAAE,CACpC;;;;IAAsC,OAAO,EAAlC,uBAAuB,EAAE,CACtC;CAAA,CAAA;AA5BD;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG"}