@platforma-sdk/block-tools 2.11.2 → 2.11.4

package/dist/index.mjs

@@ -1,20 +1,20 @@
-import { $ as e, A as t, B as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, L as f, M as p, N as m, O as h, P as g, Q as _, R as v, S as y, T as b, U as x, V as S, W as C, X as w, Y as T, Z as E, _ as D, a as O, at as k, b as A, c as j, ct as M, d as N, dt as P, et as F, f as I, ft as L, g as R, gt as z, h as B, ht as V, i as H, it as U, j as W, k as G, l as K, lt as q, m as J, mt as Y, nt as X, o as Z, ot as Q, p as $, pt as ee, q as te, r as ne, rt as re, s as ie, st as ae, t as oe, tt as se, u as ce, ut as le, v as ue, w as de, x as fe, y as pe, z as me } from "./config-DpfTzcgG.mjs";
+import { $ as e, A as t, B as n, C as r, Ct as i, D as a, E as o, F as s, G as c, H as l, I as u, J as d, K as f, L as p, M as m, N as h, O as g, P as _, Q as v, R as y, S as b, St as x, T as S, U as C, V as w, W as T, X as E, Y as D, Z as O, _ as k, _t as A, a as j, at as M, b as N, bt as P, c as F, ct as I, d as L, dt as R, et as z, f as B, ft as V, g as H, gt as U, h as W, ht as G, i as K, it as q, j as J, k as Y, l as X, lt as Z, m as Q, mt as $, nt as ee, o as te, ot as ne, p as re, pt as ie, q as ae, r as oe, rt as se, s as ce, st as le, t as ue, tt as de, u as fe, ut as pe, v as me, vt as he, w as ge, wt as _e, x as ve, xt as ye, y as be, yt as xe, z as Se } from "./config-CiC347sB.mjs";
 //#region src/registry_v1/index.ts
-var he = /* @__PURE__ */ z({
-	GlobalOverviewPath: () => ne,
-	MetaFile: () => H,
-	PlPackageConfigData: () => j,
-	PlPackageJsonConfigFile: () => K,
-	PlPackageYamlConfigFile: () => ce,
-	PlRegCommonConfigData: () => N,
-	PlRegFullPackageConfigData: () => I,
-	PlRegPackageConfig: () => oe,
-	PlRegPackageConfigDataShard: () => $,
-	packageContentPrefix: () => O,
-	packageOverviewPath: () => Z,
-	payloadFilePath: () => ie
+var Ce = /* @__PURE__ */ _e({
+	GlobalOverviewPath: () => oe,
+	MetaFile: () => K,
+	PlPackageConfigData: () => F,
+	PlPackageJsonConfigFile: () => X,
+	PlPackageYamlConfigFile: () => fe,
+	PlRegCommonConfigData: () => L,
+	PlRegFullPackageConfigData: () => B,
+	PlRegPackageConfig: () => ue,
+	PlRegPackageConfigDataShard: () => re,
+	packageContentPrefix: () => j,
+	packageOverviewPath: () => te,
+	payloadFilePath: () => ce
 });
 //#endregion
-export { S as BlockDescriptionPackageJsonField, A as BlockRegistryV2, fe as ChannelNameRegexp, y as ChannelsFolder, B as FSStorage, r as GlobalOverviewFileName, de as GlobalOverviewGzFileName, b as GlobalOverviewGzPath, a as GlobalOverviewPath, i as MainPrefix, h as ManifestFileName, G as ManifestSuffix, t as PackageManifestPattern, W as PackageOverview, p as PackageOverviewFileName, m as PackageOverviewVersionEntry, he as RegistryV1, ue as RegistryV2Reader, R as S3Storage, U as absoluteToBase64, k as absoluteToBytes, Q as absoluteToString, te as addRelativePathPrefix, w as blockComponentsManifestToAbsoluteUrl, d as buildBlockPackDist, E as consolidateBlockComponents, u as consolidateBlockPackDescription, e as consolidateBlockPackMeta, ae as cpAbsoluteToRelative, F as embedBlockPackMetaAbsoluteBase64, se as embedBlockPackMetaAbsoluteBytes, X as embedBlockPackMetaBytes, J as folderReaderByUrl, pe as inferUpdateSuggestions, c as loadPackDescription, x as loadPackDescriptionRaw, M as mapLocalToAbsolute, q as packFolderToRelativeTgz, g as packageChannelPrefix, o as packageChannelPrefixInsideV2, l as packageContentPrefix, f as packageContentPrefixInsideV2, v as packageOverviewPath, me as packageOverviewPathInsideV2, n as parseGlobalOverviewReg, C as parsePackageName, le as relativeToContentString, P as relativeToExplicitBinary64, L as relativeToExplicitBytes, ee as relativeToExplicitString, _ as resolveBlockComponents, T as resolveBlockPackDescription, re as resolveBlockPackMeta, Y as resolveModuleFile, V as resolveModuleFolder, D as storageByUrl, s as tryLoadPackDescription };
+export { c as BlockDescriptionPackageJsonField, f as BlockPackFolderName, N as BlockRegistryV2, ve as ChannelNameRegexp, b as ChannelsFolder, W as FSStorage, r as GlobalOverviewFileName, ge as GlobalOverviewGzFileName, S as GlobalOverviewGzPath, o as GlobalOverviewPath, a as MainPrefix, g as ManifestFileName, Y as ManifestSuffix, t as PackageManifestPattern, J as PackageOverview, m as PackageOverviewFileName, h as PackageOverviewVersionEntry, w as PublishedCoordsFileName, Ce as RegistryV1, me as RegistryV2Reader, H as S3Storage, V as absoluteToBase64, ie as absoluteToBytes, $ as absoluteToString, e as addRelativePathPrefix, ee as blockComponentsManifestToAbsoluteUrl, v as buildBlockPackDist, l as buildPublishedCoords, se as consolidateBlockComponents, z as consolidateBlockPackDescription, ne as consolidateBlockPackMeta, G as cpAbsoluteToRelative, le as embedBlockPackMetaAbsoluteBase64, I as embedBlockPackMetaAbsoluteBytes, Z as embedBlockPackMetaBytes, Q as folderReaderByUrl, be as inferUpdateSuggestions, ae as loadPackDescription, d as loadPackDescriptionFromManifest, D as loadPackDescriptionRaw, U as mapLocalToAbsolute, A as packFolderToRelativeTgz, _ as packageChannelPrefix, s as packageChannelPrefixInsideV2, u as packageContentPrefix, p as packageContentPrefixInsideV2, y as packageOverviewPath, Se as packageOverviewPathInsideV2, n as parseGlobalOverviewReg, E as parsePackageName, he as relativeToContentString, xe as relativeToExplicitBinary64, P as relativeToExplicitBytes, ye as relativeToExplicitString, q as resolveBlockComponents, de as resolveBlockPackDescription, pe as resolveBlockPackMeta, M as resolveManifestBlockComponents, R as resolveManifestBlockPackMeta, x as resolveModuleFile, i as resolveModuleFolder, C as resolveToRegistry, k as storageByUrl, O as tryLoadPackDescription, T as writePublishedCoords };
 
 //# sourceMappingURL=index.mjs.map

package/dist/registry_v1/config_schema.d.ts

@@ -29,8 +29,8 @@ export declare const PlRegCommonConfigData: z.ZodObject<{
     registries: Record<string, string>;
     registry?: string | undefined;
 }, {
-    registry?: string | undefined;
     registries?: Record<string, string> | undefined;
+    registry?: string | undefined;
 }>;
 export type PlRegCommonConfigData = z.infer<typeof PlRegCommonConfigData>;
 export declare const PlRegFullPackageConfigData: z.ZodObject<{
@@ -38,9 +38,9 @@ export declare const PlRegFullPackageConfigData: z.ZodObject<{
     meta: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
     files: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     version: z.ZodString;
-    registry: z.ZodString;
     package: z.ZodString;
     registries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registry: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     organization: string;
     meta: {} & {
@@ -48,17 +48,17 @@ export declare const PlRegFullPackageConfigData: z.ZodObject<{
     };
     files: Record<string, string>;
     version: string;
-    registry: string;
     package: string;
     registries: Record<string, string>;
+    registry: string;
 }, {
     organization: string;
     meta: {} & {
         [k: string]: unknown;
     };
     version: string;
-    registry: string;
     package: string;
+    registry: string;
     files?: Record<string, string> | undefined;
     registries?: Record<string, string> | undefined;
 }>;
@@ -68,25 +68,25 @@ export declare const PlRegPackageConfigDataShard: z.ZodObject<{
     meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
     files: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     version: z.ZodOptional<z.ZodString>;
-    registry: z.ZodOptional<z.ZodString>;
     package: z.ZodOptional<z.ZodString>;
     registries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registry: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     files: Record<string, string>;
     registries: Record<string, string>;
     organization?: string | undefined;
     meta?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
     version?: string | undefined;
-    registry?: string | undefined;
     package?: string | undefined;
+    registry?: string | undefined;
 }, {
     organization?: string | undefined;
     meta?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
     files?: Record<string, string> | undefined;
     version?: string | undefined;
-    registry?: string | undefined;
     package?: string | undefined;
     registries?: Record<string, string> | undefined;
+    registry?: string | undefined;
 }>;
 export type PlRegPackageConfigDataShard = z.infer<typeof PlRegPackageConfigDataShard>;
 export declare const PlPackageJsonConfigFile = "pl.package.json";

package/dist/registry_v1/flags.d.ts

@@ -1,8 +1,6 @@
+import { Option } from 'commander';
 export interface TargetFile {
     src: string;
     destName: string;
 }
-export declare const targetFile: import('@oclif/core/interfaces').FlagDefinition<TargetFile, import('@oclif/core/interfaces').CustomOptions, {
-    multiple: false;
-    requiredOrDefaulted: false;
-}>;
+export declare function targetFileOption(flags: string, summary: string): Option;

package/dist/structure/cli/run-structure.d.ts

@@ -6,7 +6,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;
 };

package/dist/structure/engine/discovery.d.ts

@@ -15,6 +15,7 @@ export type PackageJsonLike = {
     devDependencies?: Record<string, string>;
     peerDependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
+    block?: unknown;
     "block-scope"?: string;
     "block-software"?: unknown;
 };
@@ -26,11 +27,9 @@ export declare class DiscoveryError extends Error {
  * Classify one package.
  *
  * @param wp The workspace package.
- * @param siblingNames Set of all workspace package `name`s (used by
- *   rule 4 "block": depends on ≥2 sibling .model/.ui/.workflow).
  * @returns Scope or `undefined` if unclassified.
  */
-export declare function classifyOne(wp: WorkspacePackage, siblingNames: Set<string>): Scope | undefined;
+export declare function classifyOne(wp: WorkspacePackage): Scope | undefined;
 /**
  * Classify a whole workspace. Throws on the first unclassified package
  * with a message that directs the operator to add `block-scope` to its

package/dist/structure/rules/block-package-json.d.ts

@@ -1,8 +1,8 @@
 import { RunContext } from '../engine/api';
 /** The facade's `block.components` map: the dist artifact each module build
- *  emits, keyed by role. Fully determined by the discovered modules — the
- *  body rule re-asserts this exact value, so it is engine-managed (NOT an
- *  author seed). Mirrors the artifact paths produced by each scope's build:
+ *  emits, keyed by role. Fully determined by the discovered modules — the body
+ *  rule re-asserts this exact value, so it is engine-managed (NOT an author
+ *  seed). Mirrors the artifact paths produced by each scope's build:
  *  workflow → pl-tengo, model → build-model, ui → ts-builder. */
 export declare function blockComponents(ctx: RunContext): Record<string, string>;
 export declare function blockPackageJsonInitial(ctx: RunContext): Record<string, unknown>;

package/dist/structure/rules/shared/pascal-case.d.ts

@@ -0,0 +1 @@
+export declare function pascalCase(s: string): string;

package/dist/v2/index.d.ts

@@ -1,4 +1,5 @@
 export * from './model';
 export * from './build_dist';
 export * from './source_package';
+export * from './resolve_to_registry';
 export * from './registry';

package/dist/v2/model/block_components.d.ts

@@ -12,6 +12,17 @@ export type BlockComponentsAbsoluteUrl = BlockComponents<ContentAbsoluteUrl, Con
  * resolution; the UI request resolves to a folder containing `index.html`.
  */
 export declare function resolveBlockComponents(raw: BlockComponentsDescriptionRaw, moduleRoot: string): BlockComponentsDescription;
+/**
+ * Resolves a manifest's relative component paths against the `block-pack/`
+ * folder of a consumed package. Workflow main and model become absolute-file
+ * refs; the UI (a `ui.tgz` archive) resolves to its absolute path carried in
+ * the `absolute-folder` slot — `BlockComponentsDescription` types `ui` as a
+ * folder, and for manifest-consumed packs that slot holds the tgz file path
+ * (the `from-pack-v2` loader reads `.ui.folder` and feeds it to the lazy
+ * `local-tgz` frontend). Counterpart to `resolveBlockComponents`, which
+ * resolves a raw `package.json` description against authoring source.
+ */
+export declare function resolveManifestBlockComponents(manifest: BlockComponentsManifest, blockPackDir: string): BlockComponentsDescription;
 /**
  * Copies file references for workflow and model into `dstFolder`, packs the
  * UI folder into `ui.tgz`, returning the manifest form with relative paths.

package/dist/v2/model/block_meta.d.ts

@@ -7,6 +7,13 @@ export type BlockPackMetaDescription = BlockPackMeta<ContentAbsoluteTextLocal, C
  * normalization) to absolute file paths against the module root.
  */
 export declare function resolveBlockPackMeta(raw: BlockPackMetaDescriptionRaw, root: string): Promise<BlockPackMetaDescription>;
+/**
+ * Resolves a manifest's relative text/binary references against the
+ * `block-pack/` folder of a consumed package. Counterpart to
+ * `resolveBlockPackMeta` (which resolves raw `package.json` meta against
+ * authoring source); inlined explicit content passes through unchanged.
+ */
+export declare function resolveManifestBlockPackMeta(manifest: BlockPackMetaManifest, blockPackDir: string): Promise<BlockPackMetaDescription>;
 /**
  * Copies absolute text/binary file references into `dstFolder` and returns
  * the manifest form with relative paths.

package/dist/v2/resolve_to_registry.d.ts

@@ -0,0 +1,37 @@
+import { BlockPackDevV2, BlockPackFromPackV2, BlockPackFromRegistryV2, BlockPackId } from '@milaboratories/pl-model-middle-layer';
+/** File written by `block-tools publish` into `block-pack/`, carrying the
+ * registry coordinates of the published version. Holds only the immutable
+ * coordinates (CDN serve URL + version id). No `channel`: channels are moving
+ * pointers in the registry — a version can be promoted/moved later — so the
+ * channel at publish time is transient state we can't pin here. Update-checking
+ * resolves the channel at read time (`BlockPackFromRegistryV2.channel` is
+ * optional; the watcher defaults stable → any). */
+export declare const PublishedCoordsFileName = "published.json";
+/** Registry coordinates persisted in `block-pack/published.json`. */
+export interface PublishedCoords {
+    /** CDN serve URL the block is fetched from (not the S3 upload bucket). */
+    registryUrl: string;
+    id: BlockPackId;
+}
+/**
+ * Builds the `published.json` payload. Pure (no filesystem) so it is unit
+ * testable.
+ */
+export declare function buildPublishedCoords(args: {
+    registryUrl: string;
+    id: BlockPackId;
+}): PublishedCoords;
+/** Writes `block-pack/published.json` into the given block-pack folder. */
+export declare function writePublishedCoords(blockPackDir: string, coords: PublishedCoords): Promise<void>;
+/**
+ * Resolves a local block locator (`dev-v2` or `from-pack-v2`) to its registry
+ * coordinates by reading `published.json`. `published.json` lives inside the
+ * block-pack directory (written there by `block-tools publish`), so for
+ * `from-pack-v2` we read it directly from `packUrl` (converted to a path at this
+ * Node boundary) — the structurer owns the layout, we do not re-derive it. For a
+ * `dev-v2` block folder it sits under
+ * `<folder>/block-pack/`. The facade's engine-generated `from-pack-v2`
+ * BlockPointer feeds this so a consumed block can be installed via the registry
+ * path. Throws when the block was never published.
+ */
+export declare function resolveToRegistry(locator: BlockPackDevV2 | BlockPackFromPackV2): Promise<BlockPackFromRegistryV2>;

package/dist/v2/source_package.d.ts

@@ -6,3 +6,15 @@ export declare function parsePackageName(packageName: string): Pick<BlockPackId,
 export declare function tryLoadPackDescription(moduleRoot: string, logger?: MiLogger): Promise<BlockPackDescriptionAbsolute | undefined>;
 export declare function loadPackDescriptionRaw(moduleRoot: string): Promise<BlockPackDescriptionRaw>;
 export declare function loadPackDescription(moduleRoot: string): Promise<BlockPackDescriptionAbsolute>;
+/** Folder name (under a consumed package root) holding the v2 block-pack artifacts. */
+export declare const BlockPackFolderName = "block-pack";
+/**
+ * Loads a block-pack description from a block-pack directory's `manifest.json`,
+ * resolving every relative entry against that directory to an absolute
+ * filesystem path. Takes the pack directory directly (the `from-pack-v2`
+ * pointer's `packUrl`) — the structurer owns the layout, so this does not
+ * re-derive `<root>/block-pack`. Counterpart to `loadPackDescription`, which
+ * reads the authoring `block` field from `package.json` and resolves against
+ * source.
+ */
+export declare function loadPackDescriptionFromManifest(blockPackDir: string): Promise<BlockPackDescriptionAbsolute>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.11.2",
+  "version": "2.11.4",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "license": "UNLICENSED",
   "bin": {
@@ -25,8 +25,8 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.859.0",
     "@inquirer/prompts": "^7.0.1",
-    "@oclif/core": "^4.0.37",
     "canonicalize": "~2.1.0",
+    "commander": "^15.0.0",
     "lru-cache": "^11.2.2",
     "mime-types": "^2.1.35",
     "tar": "^7.4.3",
@@ -34,13 +34,12 @@
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
     "@milaboratories/pl-http": "1.2.4",
-    "@milaboratories/pl-model-middle-layer": "1.30.8",
-    "@milaboratories/pl-model-common": "1.46.2",
-    "@milaboratories/ts-helpers": "1.8.3",
+    "@milaboratories/pl-model-backend": "1.4.8",
+    "@milaboratories/pl-model-middle-layer": "1.30.9",
     "@milaboratories/resolve-helper": "1.1.3",
     "@platforma-sdk/blocks-deps-updater": "2.2.0",
-    "@milaboratories/ts-helpers-oclif": "1.1.42",
-    "@milaboratories/pl-model-backend": "1.4.8"
+    "@milaboratories/ts-helpers": "1.8.3",
+    "@milaboratories/pl-model-common": "1.46.2"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
@@ -48,7 +47,6 @@
     "@types/node": "~24.5.2",
     "@types/semver": "^7.7.0",
     "@vitest/coverage-istanbul": "^4.1.3",
-    "oclif": "^4.16.2",
     "oxfmt": "0.35.0",
     "rollup-plugin-node-externals": "^8.0.0",
     "semver": "^7.7.2",
@@ -56,25 +54,12 @@
     "vite": "^8.0.6",
     "vite-plugin-dts": "^4.5.3",
     "vitest": "^4.1.3",
-    "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/oclif-index": "1.1.1",
-    "@milaboratories/ts-configs": "1.2.3",
-    "@milaboratories/ts-builder": "1.5.2"
-  },
-  "oclif": {
-    "bin": "block-tools",
-    "commands": {
-      "identifier": "COMMANDS",
-      "strategy": "explicit",
-      "target": "./dist/cli.js"
-    },
-    "dirname": "block-tools",
-    "topicSeparator": " "
+    "@milaboratories/ts-builder": "1.6.0",
+    "@milaboratories/ts-configs": "1.3.0",
+    "@milaboratories/build-configs": "2.0.0"
   },
   "scripts": {
-    "oclif:index": "oclif-index --commands-root=./src/cmd/ --index-file=./src/cmd/index.ts && node --run fmt",
     "build": "vite build",
-    "readme": "oclif readme",
     "test": "vitest run --coverage",
     "do-pack": "rm -f *.tgz && pnpm pack && mv *.tgz package.tgz",
     "formatter:check": "ts-builder formatter --check",

package/src/cli.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import type { Command } from "commander";
+import { buildProgram } from "./cli";
+
+function subcommand(cmd: Command, name: string): Command {
+  const c = cmd.commands.find((x) => x.name() === name);
+  if (!c) throw new Error(`subcommand "${name}" not found`);
+  return c;
+}
+
+function longNames(cmd: Command): string[] {
+  return cmd.options.map((o) => o.long ?? o.short ?? o.name());
+}
+
+describe("block-tools CLI structure", () => {
+  const program = buildProgram();
+
+  it("exposes the full command surface (10 commands + structure topic)", () => {
+    expect(program.commands.map((c) => c.name()).sort()).toEqual([
+      "build-meta",
+      "build-model",
+      "list-overview-snapshots",
+      "mark-stable",
+      "pack",
+      "publish",
+      "refresh-registry",
+      "restore-overview-from-snapshot",
+      "structure",
+      "update-deps",
+      "upload-package-v1",
+    ]);
+    expect(
+      subcommand(program, "structure")
+        .commands.map((c) => c.name())
+        .sort(),
+    ).toEqual(["check", "init", "refresh"]);
+  });
+
+  it("preserves key flags + env bindings", () => {
+    const publish = subcommand(program, "publish");
+    const pnames = longNames(publish);
+    for (const f of ["--registry", "--manifest", "--version-override", "--refresh", "--unstable"]) {
+      expect(pnames).toContain(f);
+    }
+    // --no-refresh negation and PL_REGISTRY env preserved
+    expect(pnames).toContain("--no-refresh");
+    expect(publish.options.find((o) => o.long === "--registry")?.envVar).toBe("PL_REGISTRY");
+
+    // structure init keeps its positional [path] and the with/no-software pair
+    const init = subcommand(subcommand(program, "structure"), "init");
+    const inames = longNames(init);
+    expect(inames).toContain("--with-software");
+    expect(inames).toContain("--no-software");
+    expect(init.registeredArguments.map((a) => a.name())).toContain("path");
+  });
+});

package/src/cli.ts

@@ -0,0 +1,50 @@
+import { Command } from "commander";
+import { buildMetaCommand } from "./cmd/build-meta";
+import { buildModelCommand } from "./cmd/build-model";
+import { packCommand } from "./cmd/pack";
+import { publishCommand } from "./cmd/publish";
+import { refreshRegistryCommand } from "./cmd/refresh-registry";
+import { markStableCommand } from "./cmd/mark-stable";
+import { updateDepsCommand } from "./cmd/update-deps";
+import { listOverviewSnapshotsCommand } from "./cmd/list-overview-snapshots";
+import { restoreOverviewFromSnapshotCommand } from "./cmd/restore-overview-from-snapshot";
+import { uploadPackageV1Command } from "./cmd/upload-package-v1";
+import { structureCheckCommand } from "./cmd/structure/check";
+import { structureInitCommand } from "./cmd/structure/init";
+import { structureRefreshCommand } from "./cmd/structure/refresh";
+
+// `packageRoot` is the package install root (the dir containing `src/` and
+// `bin/`); the `structure` commands resolve their templates under it. bin/run.js
+// passes it in; defaults to cwd for tests/introspection.
+export function buildProgram(packageRoot: string = process.cwd()): Command {
+  const program = new Command();
+  program
+    .name("block-tools")
+    .description("Utility to manipulate Platforma Blocks and Block Registry");
+
+  program.addCommand(buildMetaCommand());
+  program.addCommand(buildModelCommand());
+  program.addCommand(packCommand());
+  program.addCommand(publishCommand());
+  program.addCommand(refreshRegistryCommand());
+  program.addCommand(markStableCommand());
+  program.addCommand(updateDepsCommand(packageRoot));
+  program.addCommand(listOverviewSnapshotsCommand());
+  program.addCommand(restoreOverviewFromSnapshotCommand());
+  program.addCommand(uploadPackageV1Command());
+
+  // `structure` subcommands: check | init | refresh.
+  const structure = new Command("structure").description(
+    "Manage block scaffolding against the canonical structure (check / init / refresh)",
+  );
+  structure.addCommand(structureCheckCommand(packageRoot));
+  structure.addCommand(structureInitCommand(packageRoot));
+  structure.addCommand(structureRefreshCommand(packageRoot));
+  program.addCommand(structure);
+
+  return program;
+}
+
+export async function run(argv: string[], packageRoot: string): Promise<void> {
+  await buildProgram(packageRoot).parseAsync(argv);
+}

package/src/cmd/build-meta.ts

@@ -1,32 +1,19 @@
-import { Command, Flags } from "@oclif/core";
+import { Command } from "commander";
 import path from "node:path";
 import fs from "node:fs";
 import { loadPackDescriptionRaw } from "../v2";
 import { embedBlockPackMetaAbsoluteBase64, resolveBlockPackMeta } from "../v2/model/block_meta";
 
-export default class BuildMeta extends Command {
-  static override description =
+export function buildMetaCommand(): Command {
+  const cmd = new Command("build-meta").description(
     "Extracts meta information from blocks package.json and outputs meta.json with embedded binary " +
-    "and textual information linked from the meta section.";
+      "and textual information linked from the meta section.",
+  );
 
-  static flags = {
-    modulePath: Flags.string({
-      char: "i",
-      summary: "input module path",
-      helpValue: "<path>",
-      default: ".",
-    }),
+  cmd.option("-i, --modulePath <path>", "input module path", ".");
+  cmd.requiredOption("-o, --destination <path>", "output meta.json file");
 
-    destination: Flags.string({
-      char: "o",
-      summary: "output meta.json file",
-      helpValue: "<path>",
-      required: true,
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { flags } = await this.parse(BuildMeta);
+  cmd.action(async (flags) => {
     const modulePath = path.resolve(flags.modulePath);
     const descriptionRaw = await loadPackDescriptionRaw(modulePath);
     const metaEmbedded = await embedBlockPackMetaAbsoluteBase64(
@@ -34,5 +21,7 @@ export default class BuildMeta extends Command {
     );
 
     await fs.promises.writeFile(path.resolve(flags.destination), JSON.stringify(metaEmbedded));
-  }
+  });
+
+  return cmd;
 }

package/src/cmd/build-model.ts

@@ -1,4 +1,4 @@
-import { Command, Flags } from "@oclif/core";
+import { Command } from "commander";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -13,44 +13,26 @@ async function getFileContent(path: string) {
   }
 }
 
-export default class BuildModel extends Command {
-  static override description =
-    "Extracts and outputs block model JSON from pre-built block model module";
+export function buildModelCommand(): Command {
+  const cmd = new Command("build-model").description(
+    "Extracts and outputs block model JSON from pre-built block model module",
+  );
 
-  static flags = {
-    modulePath: Flags.string({
-      char: "i",
-      summary: "input module path",
-      helpValue: "<path>",
-      default: ".",
-    }),
+  cmd.option("-i, --modulePath <path>", "input module path", ".");
+  cmd.option(
+    "-b, --sourceBundle <path>",
+    "bundled model code to embed into the model for callback-based rendering to work",
+    "./dist/bundle.js",
+  );
+  cmd.option("-o, --destination <path>", "output model file", "./dist/model.json");
 
-    sourceBundle: Flags.string({
-      char: "b",
-      summary: "bundled model code to embed into the model for callback-based rendering to work",
-      helpValue: "<path>",
-      default: "./dist/bundle.js",
-    }),
-
-    destination: Flags.string({
-      char: "o",
-      summary: "output model file",
-      helpValue: "<path>",
-      default: "./dist/model.json",
-    }),
-  };
-
-  public async run(): Promise<void> {
-    const { flags } = await this.parse(BuildModel);
+  cmd.action(async (flags) => {
     const modulePath = path.resolve(flags.modulePath); // i.e. folder with package.json file
-    // eslint-disable-next-line prefer-const, @typescript-eslint/no-unsafe-assignment
     let { model, platforma } = require(modulePath);
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     if (!model) model = platforma;
     if (!model) throw new Error('"model" export not found');
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const { config } = model;
 
     if (!config)
@@ -64,7 +46,6 @@ export default class BuildModel extends Command {
 
     const code = await getFileContent(flags.sourceBundle);
     if (code !== undefined) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       config.code = {
         type: "plain",
         content: code,
@@ -72,5 +53,7 @@ export default class BuildModel extends Command {
     }
 
     await fs.promises.writeFile(path.resolve(flags.destination), JSON.stringify(config));
-  }
+  });
+
+  return cmd;
 }