@platforma-sdk/block-tools 2.11.2 → 2.11.3

package/src/cmd/refresh-registry.ts

@@ -1,34 +1,30 @@
-import { Command, Flags } from "@oclif/core";
+import { Command, Option } from "commander";
 import { BlockRegistryV2 } from "../v2";
 import { storageByUrl } from "../io";
-import { OclifLoggerAdapter } from "@milaboratories/ts-helpers-oclif";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 
-export default class RefreshRegistry extends Command {
-  static description = "Refresh overview files based on published but not proecessed artefacts";
+export function refreshRegistryCommand(): Command {
+  const cmd = new Command("refresh-registry").description(
+    "Refresh overview files based on published but not proecessed artefacts",
+  );
 
-  static flags = {
-    registry: Flags.string({
-      char: "r",
-      summary: "full address of the registry",
-      helpValue: "<address>",
-      env: "PL_REGISTRY",
-      required: true,
-    }),
+  cmd.addOption(
+    new Option("-r, --registry <address>", "full address of the registry")
+      .env("PL_REGISTRY")
+      .makeOptionMandatory(),
+  );
+  cmd.addOption(
+    new Option("-m, --mode <mode>", 'refresh mode (allowed valiues: "force", "normal", "dry-run")')
+      .choices(["force", "normal", "dry-run"])
+      .env("PL_REGISTRY_REFRESH_DRY_RUN")
+      .default("normal"),
+  );
 
-    mode: Flags.string({
-      char: "m",
-      summary: 'refresh mode (allowed valiues: "force", "normal", "dry-run")',
-      helpValue: "<mode>",
-      options: ["force", "normal", "dry-run"],
-      env: "PL_REGISTRY_REFRESH_DRY_RUN",
-      default: "normal",
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { flags } = await this.parse(RefreshRegistry);
+  cmd.action(async (flags) => {
     const storage = storageByUrl(flags.registry);
-    const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
+    const registry = new BlockRegistryV2(storage, new ConsoleLoggerAdapter());
     await registry.updateIfNeeded(flags.mode as "force" | "normal" | "dry-run");
-  }
+  });
+
+  return cmd;
 }

package/src/cmd/restore-overview-from-snapshot.ts

@@ -1,44 +1,32 @@
-import { Command, Flags } from "@oclif/core";
+import { Command, Option } from "commander";
 import { BlockRegistryV2 } from "../v2/registry/registry";
 import { storageByUrl } from "../io/storage";
-import { OclifLoggerAdapter } from "@milaboratories/ts-helpers-oclif";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 
-export default class RestoreOverviewFromSnapshot extends Command {
-  static description = "Restore global overview from a snapshot";
+export function restoreOverviewFromSnapshotCommand(): Command {
+  const cmd = new Command("restore-overview-from-snapshot").description(
+    "Restore global overview from a snapshot",
+  );
 
-  static flags = {
-    registry: Flags.string({
-      char: "r",
-      summary: "full address of the registry",
-      helpValue: "<address>",
-      env: "PL_REGISTRY",
-      required: true,
-    }),
+  cmd.addOption(
+    new Option("-r, --registry <address>", "full address of the registry")
+      .env("PL_REGISTRY")
+      .makeOptionMandatory(),
+  );
+  cmd.requiredOption("-s, --snapshot <timestamp>", "snapshot timestamp ID to restore from");
+  cmd.option("--skip-confirmation", "skip confirmation prompt (use with caution)", false);
 
-    snapshot: Flags.string({
-      char: "s",
-      summary: "snapshot timestamp ID to restore from",
-      helpValue: "<timestamp>",
-      required: true,
-    }),
-
-    "skip-confirmation": Flags.boolean({
-      summary: "skip confirmation prompt (use with caution)",
-      default: false,
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { flags } = await this.parse(RestoreOverviewFromSnapshot);
+  cmd.action(async (flags) => {
+    const logger = new ConsoleLoggerAdapter();
     const storage = storageByUrl(flags.registry);
-    const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
+    const registry = new BlockRegistryV2(storage, logger);
 
     // Check if snapshot exists
     const snapshots = await registry.listGlobalOverviewSnapshots();
     const targetSnapshot = snapshots.find((s) => s.timestamp === flags.snapshot);
 
     if (!targetSnapshot) {
-      this.error(
+      throw new Error(
         `Snapshot '${flags.snapshot}' not found. Available snapshots:\n${
           snapshots.map((s) => `  - ${s.timestamp}`).join("\n") || "  (none)"
         }`,
@@ -46,7 +34,7 @@ export default class RestoreOverviewFromSnapshot extends Command {
     }
 
     // Confirmation prompt (unless skipped)
-    if (!flags["skip-confirmation"]) {
+    if (!flags.skipConfirmation) {
       const readline = await import("node:readline");
       const rl = readline.createInterface({
         input: process.stdin,
@@ -64,7 +52,7 @@ export default class RestoreOverviewFromSnapshot extends Command {
       rl.close();
 
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
-        this.log("Restore cancelled.");
+        logger.info("Restore cancelled.");
         return;
       }
     }
@@ -72,9 +60,11 @@ export default class RestoreOverviewFromSnapshot extends Command {
     // Perform restore
     try {
       await registry.restoreGlobalOverviewFromSnapshot(flags.snapshot);
-      this.log(`✅ Successfully restored global overview from snapshot '${flags.snapshot}'`);
+      logger.info(`✅ Successfully restored global overview from snapshot '${flags.snapshot}'`);
     } catch (error) {
-      this.error(`Failed to restore from snapshot: ${String(error)}`);
+      throw new Error(`Failed to restore from snapshot: ${String(error)}`);
     }
-  }
+  });
+
+  return cmd;
 }

package/src/cmd/structure/check.ts

@@ -1,51 +1,42 @@
-import { Command, Flags } from "@oclif/core";
+import { Command } from "commander";
 import path from "node:path";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 import { runStructureForPath, formatChanges } from "../../structure/cli/run-structure";
 
-export default class StructureCheck extends Command {
-  static override description =
-    "Check block(s) against the canonical structure (read-only). Exits non-zero if any diff would land — used as the CI gate.";
-
-  static override examples = [
-    "<%= config.bin %> <%= command.id %> ./my-block",
-    "<%= config.bin %> <%= command.id %> --sdk-internal etc/blocks/*",
-  ];
+export function structureCheckCommand(packageRoot: string): Command {
+  const cmd = new Command("check").description(
+    "Check block(s) against the canonical structure (read-only). Exits non-zero if any diff would land — used as the CI gate.",
+  );
 
   // Variadic positional block paths (shell-expanded globs).
-  static override strict = false;
-
-  static override flags = {
-    "sdk-internal": Flags.boolean({
-      description: "block(s) live inside the SDK monorepo; skip root-scope rules",
-    }),
-  };
+  cmd.argument("[paths...]", "block path(s); defaults to the current directory");
+  cmd.option("--sdk-internal", "block(s) live inside the SDK monorepo; skip root-scope rules");
 
-  public async run(): Promise<void> {
-    const { argv, flags } = await this.parse(StructureCheck);
-    const paths = (argv as string[]).length > 0 ? (argv as string[]) : ["."];
-    const templatesRoot = path.join(this.config.root, "src", "structure", "templates");
+  cmd.action(async (argv: string[], flags) => {
+    const logger = new ConsoleLoggerAdapter();
+    const paths = argv.length > 0 ? argv : ["."];
+    const templatesRoot = path.join(packageRoot, "src", "structure", "templates");
 
     let anyChanged = false;
     for (const p of paths) {
       const res = await runStructureForPath({
         blockPath: p,
-        isSdkInternal: flags["sdk-internal"],
+        isSdkInternal: Boolean(flags.sdkInternal),
         updateDepsOnly: false,
         mode: "check",
         templatesRoot,
-        log: (m) => this.log(m),
+        log: (m) => logger.info(m),
       });
-      this.log(formatChanges(p, res.changes));
+      logger.info(formatChanges(p, res.changes));
       if (res.changes.length > 0) anyChanged = true;
     }
 
     if (anyChanged) {
-      this.error(
+      throw new Error(
         "Structure check failed: one or more blocks are out of date. Run `structure refresh`.",
-        {
-          exit: 1,
-        },
       );
     }
-  }
+  });
+
+  return cmd;
 }

package/src/cmd/structure/init.ts

@@ -1,5 +1,6 @@
-import { Args, Command, Flags } from "@oclif/core";
+import { Command, Option } from "commander";
 import path from "node:path";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 import {
   resolveBlockVars,
   runInit,
@@ -7,59 +8,51 @@ import {
   type InitFlagValues,
 } from "../../structure/init-block-constructor";
 
-export default class StructureInit extends Command {
-  static override description =
-    "Scaffold a fresh Platforma block from the canonical structure. Missing flags are prompted unless --non-interactive.";
-
-  static override examples = [
-    "<%= config.bin %> <%= command.id %> --npm-org @platforma-open --org-scope my-org --short-name demo --no-software --non-interactive",
-    "<%= config.bin %> <%= command.id %> ./demo --npm-org @platforma-open --org-scope my-org --short-name demo --with-software --platform python --non-interactive",
-  ];
-
-  static override args = {
-    path: Args.string({
-      description: "target directory (default: <short-name> under the current directory)",
-    }),
-  };
-
-  static override flags = {
-    "npm-org": Flags.string({ description: "npm org, e.g. @platforma-open" }),
-    "org-scope": Flags.string({ description: "org scope, e.g. my-org" }),
-    "short-name": Flags.string({ description: "block short name, e.g. mixcr-clonotyping" }),
-    "with-software": Flags.boolean({ description: "include a software module" }),
-    "no-software": Flags.boolean({ description: "omit the software module" }),
-    platform: Flags.string({
-      description: "software platform (single-valued)",
-      options: [...SUPPORTED_PLATFORMS],
-    }),
-    "non-interactive": Flags.boolean({
-      description: "error on any missing flag instead of prompting",
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { args, flags } = await this.parse(StructureInit);
-
-    if (flags["with-software"] && flags["no-software"]) {
-      this.error("--with-software and --no-software are mutually exclusive.");
+export function structureInitCommand(packageRoot: string): Command {
+  const cmd = new Command("init").description(
+    "Scaffold a fresh Platforma block from the canonical structure. Missing flags are prompted unless --non-interactive.",
+  );
+
+  cmd.argument("[path]", "target directory (default: <short-name> under the current directory)");
+  cmd.option("--npm-org <org>", "npm org, e.g. @platforma-open");
+  cmd.option("--org-scope <scope>", "org scope, e.g. my-org");
+  cmd.option("--short-name <name>", "block short name, e.g. mixcr-clonotyping");
+  cmd.option("--with-software", "include a software module");
+  cmd.option("--no-software", "omit the software module");
+  cmd.addOption(
+    new Option("--platform <platform>", "software platform (single-valued)").choices([
+      ...SUPPORTED_PLATFORMS,
+    ]),
+  );
+  cmd.option("--non-interactive", "error on any missing flag instead of prompting");
+
+  cmd.action(async (argPath: string | undefined, flags) => {
+    const logger = new ConsoleLoggerAdapter();
+
+    // commander maps `--with-software` -> flags.withSoftware===true and
+    // `--no-software` -> flags.software===false
+    const withSoftwareFlag = flags.withSoftware === true;
+    const noSoftwareFlag = flags.software === false;
+    if (withSoftwareFlag && noSoftwareFlag) {
+      throw new Error("--with-software and --no-software are mutually exclusive.");
     }
-    const withSoftware = flags["with-software"] ? true : flags["no-software"] ? false : undefined;
+    const withSoftware = withSoftwareFlag ? true : noSoftwareFlag ? false : undefined;
 
     const flagValues: InitFlagValues = {
-      npmOrg: flags["npm-org"],
-      orgScope: flags["org-scope"],
-      shortName: flags["short-name"],
+      npmOrg: flags.npmOrg,
+      orgScope: flags.orgScope,
+      shortName: flags.shortName,
       withSoftware,
       platform: flags.platform,
-      nonInteractive: flags["non-interactive"],
+      nonInteractive: flags.nonInteractive,
     };
 
     const vars = await resolveBlockVars(flagValues);
-    const blockPath = args.path
-      ? path.resolve(args.path)
-      : path.resolve(process.cwd(), vars.shortName);
-    const templatesRoot = path.join(this.config.root, "src", "structure", "templates");
+    const blockPath = argPath ? path.resolve(argPath) : path.resolve(process.cwd(), vars.shortName);
+    const templatesRoot = path.join(packageRoot, "src", "structure", "templates");
+
+    await runInit({ vars, blockPath, templatesRoot, log: (m) => logger.info(m) });
+  });
 
-    await runInit({ vars, blockPath, templatesRoot, log: (m) => this.log(m) });
-  }
+  return cmd;
 }

package/src/cmd/structure/refresh.ts

@@ -1,44 +1,53 @@
-import { Command, Flags } from "@oclif/core";
+import { Command } from "commander";
 import path from "node:path";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 import { runStructureForPath, formatChanges } from "../../structure/cli/run-structure";
 
-export default class StructureRefresh extends Command {
-  static override description =
-    "Bring block(s) up to date with the canonical structure. Applies rules, writes files, bumps .structure version. Default mode is offline; --update-deps-only fires only catalog-bump rules (network).";
-
-  static override examples = [
-    "<%= config.bin %> <%= command.id %> ./my-block",
-    "<%= config.bin %> <%= command.id %> --sdk-internal etc/blocks/*",
-    "<%= config.bin %> <%= command.id %> --update-deps-only",
-  ];
+// Shared by `structure refresh` and the deprecated `update-deps` alias.
+export async function runRefresh(opts: {
+  paths: string[];
+  isSdkInternal: boolean;
+  updateDepsOnly: boolean;
+  templatesRoot: string;
+  logger: MiLogger;
+}): Promise<void> {
+  for (const p of opts.paths) {
+    const res = await runStructureForPath({
+      blockPath: p,
+      isSdkInternal: opts.isSdkInternal,
+      updateDepsOnly: opts.updateDepsOnly,
+      mode: "refresh",
+      templatesRoot: opts.templatesRoot,
+      log: (m) => opts.logger.info(m),
+    });
+    opts.logger.info(formatChanges(p, res.changes));
+  }
+}
 
-  static override strict = false;
+export function structureRefreshCommand(packageRoot: string): Command {
+  const cmd = new Command("refresh").description(
+    "Bring block(s) up to date with the canonical structure. Applies rules, writes files, bumps .structure version. Default mode is offline; --update-deps-only fires only catalog-bump rules (network).",
+  );
 
-  static override flags = {
-    "sdk-internal": Flags.boolean({
-      description: "block(s) live inside the SDK monorepo; skip root-scope rules",
-    }),
-    "update-deps-only": Flags.boolean({
-      description:
-        "fire ONLY catalog-bump rules (npm network). Follow with `pnpm install` then a plain refresh.",
-    }),
-  };
+  cmd.argument("[paths...]", "block path(s); defaults to the current directory");
+  cmd.option("--sdk-internal", "block(s) live inside the SDK monorepo; skip root-scope rules");
+  cmd.option(
+    "--update-deps-only",
+    "fire ONLY catalog-bump rules (npm network). Follow with `pnpm install` then a plain refresh.",
+  );
 
-  public async run(): Promise<void> {
-    const { argv, flags } = await this.parse(StructureRefresh);
-    const paths = (argv as string[]).length > 0 ? (argv as string[]) : ["."];
-    const templatesRoot = path.join(this.config.root, "src", "structure", "templates");
+  cmd.action(async (argv: string[], flags) => {
+    const paths = argv.length > 0 ? argv : ["."];
+    const templatesRoot = path.join(packageRoot, "src", "structure", "templates");
+    await runRefresh({
+      paths,
+      isSdkInternal: Boolean(flags.sdkInternal),
+      updateDepsOnly: Boolean(flags.updateDepsOnly),
+      templatesRoot,
+      logger: new ConsoleLoggerAdapter(),
+    });
+  });
 
-    for (const p of paths) {
-      const res = await runStructureForPath({
-        blockPath: p,
-        isSdkInternal: flags["sdk-internal"],
-        updateDepsOnly: flags["update-deps-only"],
-        mode: "refresh",
-        templatesRoot,
-        log: (m) => this.log(m),
-      });
-      this.log(formatChanges(p, res.changes));
-    }
-  }
+  return cmd;
 }

package/src/cmd/update-deps.ts

@@ -1,4 +1,7 @@
-import { Command } from "@oclif/core";
+import { Command } from "commander";
+import path from "node:path";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
+import { runRefresh } from "./structure/refresh";
 
 /**
  * Deprecated. Phase-2 forwarding alias (spec.md § "Coexistence And
@@ -7,19 +10,26 @@ import { Command } from "@oclif/core";
  * semantics. Prints a deprecation warning; will be removed once the
  * structurer path has been live without surprises.
  */
-export default class UpdateDeps extends Command {
-  static override description =
-    "[DEPRECATED] Use `block-tools structure refresh --update-deps-only`. This alias delegates to it.";
+export function updateDepsCommand(packageRoot: string): Command {
+  const cmd = new Command("update-deps").description(
+    "[DEPRECATED] Use `block-tools structure refresh --update-deps-only`. This alias delegates to it.",
+  );
 
-  static override examples = ["<%= config.bin %> <%= command.id %>"];
-
-  public async run(): Promise<void> {
-    this.warn(
+  cmd.action(async () => {
+    const logger = new ConsoleLoggerAdapter();
+    logger.warn(
       "`block-tools update-deps` is deprecated and will be removed in a future release. " +
         "Use `block-tools structure refresh --update-deps-only` instead. Delegating now.",
     );
-    // oclif resolves commands by their internal colon-form id, even
-    // though the user-facing form uses the configured " " topic separator.
-    await this.config.runCommand("structure:refresh", ["--update-deps-only"]);
-  }
+    const templatesRoot = path.join(packageRoot, "src", "structure", "templates");
+    await runRefresh({
+      paths: ["."],
+      isSdkInternal: false,
+      updateDepsOnly: true,
+      templatesRoot,
+      logger,
+    });
+  });
+
+  return cmd;
 }

package/src/cmd/upload-package-v1.ts

@@ -1,67 +1,47 @@
-import { Command, Flags } from "@oclif/core";
+import { Command, Option } from "commander";
 import { getConfig } from "../registry_v1/config";
-import { targetFile } from "../registry_v1/flags";
+import { targetFileOption } from "../registry_v1/flags";
 import fs from "node:fs";
 import YAML from "yaml";
 import { PlRegPackageConfigDataShard } from "../registry_v1/config_schema";
-import { OclifLoggerAdapter } from "@milaboratories/ts-helpers-oclif";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
 
 type BasicConfigField = keyof PlRegPackageConfigDataShard &
   ("registry" | "organization" | "package" | "version");
 const BasicConfigFields: BasicConfigField[] = ["registry", "organization", "package", "version"];
 
-export default class UploadPackageV1 extends Command {
-  static description = "Uploads V1 package and refreshes the registry";
-
-  static flags = {
-    registry: Flags.string({
-      char: "r",
-      summary: "full address of the registry or alias from .pl.reg",
-      helpValue: "<address|alias>",
-      env: "PL_REGISTRY",
-    }),
-
-    organization: Flags.string({
-      char: "o",
-      summary: "target organisation",
-      env: "PL_PACKAGE_ORGANIZATION",
-    }),
-
-    package: Flags.string({
-      char: "p",
-      summary: "target package",
-      env: "PL_PACKAGE_NAME",
-    }),
-
-    version: Flags.string({
-      char: "v",
-      summary: "target version",
-      env: "PL_PACKAGE_VERSION",
-    }),
-
-    meta: Flags.file({
-      char: "m",
-      summary: "json file containing meta information to associate with tha package",
-      exists: true,
-    }),
-
-    file: targetFile({
-      char: "f",
-      summary: "package files",
-      multiple: true,
-      default: [],
-    }),
-
-    refresh: Flags.boolean({
-      summary: "refresh repository after adding the package",
-      default: true,
-      allowNo: true,
-      env: "PL_REGISTRY_REFRESH",
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { flags } = await this.parse(UploadPackageV1);
+export function uploadPackageV1Command(): Command {
+  const cmd = new Command("upload-package-v1").description(
+    "Uploads V1 package and refreshes the registry",
+  );
+
+  cmd.addOption(
+    new Option(
+      "-r, --registry <address|alias>",
+      "full address of the registry or alias from .pl.reg",
+    ).env("PL_REGISTRY"),
+  );
+  cmd.addOption(
+    new Option("-o, --organization <organization>", "target organisation").env(
+      "PL_PACKAGE_ORGANIZATION",
+    ),
+  );
+  cmd.addOption(new Option("-p, --package <package>", "target package").env("PL_PACKAGE_NAME"));
+  cmd.addOption(new Option("-v, --version <version>", "target version").env("PL_PACKAGE_VERSION"));
+  cmd.option(
+    "-m, --meta <path>",
+    "json file containing meta information to associate with tha package",
+  );
+  cmd.addOption(targetFileOption("-f, --file <file>", "package files"));
+  cmd.addOption(
+    new Option("--refresh", "refresh repository after adding the package")
+      .default(true)
+      .env("PL_REGISTRY_REFRESH"),
+  );
+  cmd.option("--no-refresh", "do not refresh repository after adding the package");
+
+  cmd.action(async (flags) => {
+    const logger = new ConsoleLoggerAdapter();
     const configFromFlags: PlRegPackageConfigDataShard = PlRegPackageConfigDataShard.parse({});
 
     for (const field of BasicConfigFields) if (flags[field]) configFromFlags[field] = flags[field];
@@ -83,23 +63,25 @@ export default class UploadPackageV1 extends Command {
 
     const conf = await getConfig(configFromFlags);
 
-    this.log(YAML.stringify(conf.conf));
+    logger.info(YAML.stringify(conf.conf));
 
-    const registry = conf.createRegistry(new OclifLoggerAdapter(this));
+    const registry = conf.createRegistry(logger);
     const name = conf.fullPackageName;
 
     const builder = registry.constructNewPackage(name);
 
     for (const [dst, src] of Object.entries(conf.conf.files)) {
-      this.log(`Uploading ${src} -> ${dst} ...`);
+      logger.info(`Uploading ${src} -> ${dst} ...`);
       const content = await fs.promises.readFile(src);
       await builder.addFile(dst, content);
     }
 
-    this.log(`Uploading meta information...`);
+    logger.info(`Uploading meta information...`);
     await builder.writeMeta(conf.conf.meta);
     await builder.finish();
 
     if (flags.refresh) await registry.updateIfNeeded();
-  }
+  });
+
+  return cmd;
 }

package/src/registry_v1/flags.ts

@@ -1,4 +1,4 @@
-import { Flags } from "@oclif/core";
+import { Option } from "commander";
 import path from "node:path";
 
 export interface TargetFile {
@@ -16,9 +16,9 @@ function parseTargetFile(arg: string): TargetFile {
   }
 }
 
-export const targetFile = Flags.custom<TargetFile>({
-  summary: "target files to upload",
-  helpValue: "file_path | package_name=file_path",
-  // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but parsing is sync
-  parse: async (arg) => parseTargetFile(arg),
-});
+// Repeatable `file_path | package_name=file_path` option.
+export function targetFileOption(flags: string, summary: string): Option {
+  return new Option(flags, summary)
+    .argParser((arg: string, prev?: TargetFile[]) => [...(prev ?? []), parseTargetFile(arg)])
+    .default([] as TargetFile[]);
+}

package/src/structure/cli/run-structure.ts

@@ -1,5 +1,5 @@
 // Shared driver for the `structure check` and `structure refresh`
-// oclif commands. Wraps DISCOVERY (discover-fs) + the engine runner for
+// commands. Wraps DISCOVERY (discover-fs) + the engine runner for
 // one block path, handling the standalone vs `--sdk-internal` split, the
 // `--update-deps-only` registry prefetch, and the post-run recheck's
 // fresh re-discovery. Each block path is processed independently (no
@@ -26,7 +26,7 @@ export type RunStructureInput = {
   isSdkInternal: boolean;
   updateDepsOnly: boolean;
   mode: StructureMode;
-  /** `<block-tools>/src/structure/templates` (from oclif `config.root`). */
+  /** `<block-tools>/src/structure/templates`. */
   templatesRoot: string;
   log: (msg: string) => void;
 };