@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/serialization/api/items.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSerializationCommands = exports.fetchItemData = exports.fetchItemMetadata = void 0;
+const item_path_1 = require("../item-path");
+const signature_1 = require("../signature");
+const errors_1 = require("../../shared/errors");
+const graphql_1 = require("./graphql");
+const serializeMetadataFragment = `
+  serialize(path: $path, database: $database, scope: $scope, excludedFieldIds: $excludedFieldIds) {
+    id
+    parentId
+    templateId
+    path
+    hasChildren
+    dataSignature
+  }
+`;
+const serializeMetadataDebugFragment = serializeMetadataFragment.replace("dataSignature", "dataSignature(debug: true)");
+const serializeDataFragment = `
+  serialize(path: $path, database: $database, scope: $scope, excludedFieldIds: $excludedFieldIds) {
+    data
+  }
+`;
+const executeSerializationCommandsMutation = `
+mutation($commands: [ItemCommand], $minimumLogLevel: LogLevel) {
+  executeSerializationCommands(commands: $commands, minimumLogLevel: $minimumLogLevel) {
+    success
+    name
+    messages {
+      logLevel
+      eventID { id name }
+      message
+    }
+  }
+}`;
+const mapScope = (scope) => {
+    if (scope.toLowerCase() === "singleitem") {
+        return "SingleItem";
+    }
+    if (scope.toLowerCase() === "itemandchildren") {
+        return "ItemAndChildren";
+    }
+    if (scope.toLowerCase() === "descendantsonly") {
+        return "DescendantsOnly";
+    }
+    return "ItemAndDescendants";
+};
+const parseItemData = (data, database) => {
+    if (!data || typeof data !== "string") {
+        throw (0, errors_1.createScaiError)("GraphQL response did not contain serialized item data.", "UNKNOWN");
+    }
+    const parsed = JSON.parse(data);
+    const versions = parsed.versions?.map((version) => ({
+        language: version.language,
+        version: version.version,
+        fields: version.fields.map((field) => ({
+            fieldId: field.fieldId,
+            nameHint: field.nameHint,
+            value: field.value ?? "",
+            blobId: field.blobId ?? null,
+        })),
+    })) ?? [];
+    const item = {
+        id: parsed.id,
+        parentId: parsed.parentId,
+        templateId: parsed.templateId,
+        path: item_path_1.ItemPath.fromPathString(parsed.path.toString()),
+        name: parsed.name,
+        branchId: parsed.branchId,
+        database,
+        sharedFields: parsed.sharedFields.map((field) => ({
+            fieldId: field.fieldId,
+            nameHint: field.nameHint,
+            value: field.value ?? "",
+            blobId: field.blobId ?? null,
+        })),
+        unversionedFields: parsed.unversionedFields.map((language) => ({
+            language: language.language,
+            fields: language.fields.map((field) => ({
+                fieldId: field.fieldId,
+                nameHint: field.nameHint,
+                value: field.value ?? "",
+                blobId: field.blobId ?? null,
+            })),
+        })),
+        versions,
+        dataSignature: parsed.dataSignature,
+    };
+    if (!item.dataSignature) {
+        const base = (0, signature_1.createDataSignatureBase)(item);
+        item.dataSignature = (0, signature_1.createSignature)(base) ?? "";
+    }
+    return item;
+};
+const fetchItemMetadata = async (environment, database, pathOrId, scope, fieldFilter, useDebugSignatures, options) => {
+    const query = `query($path: String!, $database: String!, $scope: TreeScope!, $excludedFieldIds: [String]) { ${useDebugSignatures ? serializeMetadataDebugFragment : serializeMetadataFragment} }`;
+    const data = await (0, graphql_1.runGraphQL)(environment, query, {
+        path: pathOrId,
+        database,
+        scope: mapScope(scope),
+        excludedFieldIds: Array.from(fieldFilter.excludes),
+    }, options);
+    return data.serialize.map((item) => ({
+        id: item.id,
+        parentId: item.parentId,
+        templateId: item.templateId,
+        path: item_path_1.ItemPath.fromPathString(item.path),
+        hasChildren: item.hasChildren,
+        dataSignature: item.dataSignature,
+        database,
+    }));
+};
+exports.fetchItemMetadata = fetchItemMetadata;
+const fetchItemData = async (environment, database, pathOrId, scope, fieldFilter, options) => {
+    const query = `query($path: String!, $database: String!, $scope: TreeScope!, $excludedFieldIds: [String]) { ${serializeDataFragment} }`;
+    const data = await (0, graphql_1.runGraphQL)(environment, query, {
+        path: pathOrId,
+        database,
+        scope: mapScope(scope),
+        excludedFieldIds: Array.from(fieldFilter.excludes),
+    }, options);
+    return data.serialize.map((entry) => parseItemData(entry.data, database));
+};
+exports.fetchItemData = fetchItemData;
+const executeSerializationCommands = async (environment, commands, minimumLogLevel, options) => {
+    const data = await (0, graphql_1.runGraphQL)(environment, executeSerializationCommandsMutation, {
+        commands,
+        minimumLogLevel,
+    }, options);
+    return data.executeSerializationCommands;
+};
+exports.executeSerializationCommands = executeSerializationCommands;

package/dist/serialization/api/publish.d.ts

@@ -0,0 +1,43 @@
+import type { SitecoreApiClientOptions } from "./types";
+import { GraphQLRequestOptions } from "./graphql";
+export declare const publishItems: (environment: SitecoreApiClientOptions, itemIds: string[], target?: string, options?: GraphQLRequestOptions) => Promise<{
+    id: string;
+    processedCount: number;
+    stateName: string;
+}>;
+export declare const checkPublishStatus: (environment: SitecoreApiClientOptions, publishId: string, options?: GraphQLRequestOptions) => Promise<{
+    id: string;
+    processedCount: number;
+    stateName: string;
+}>;
+export declare const fetchPublishingTargets: (environment: SitecoreApiClientOptions, options?: GraphQLRequestOptions) => Promise<string[]>;
+/** Outcome of {@link publishItemSubtree}. */
+export interface PublishItemSubtreeResult {
+    /** Source item path that was published. */
+    path: string;
+    /** Source database the items were read from. */
+    database: string;
+    /** Publish target, when one was given. */
+    target?: string;
+    /** Number of items resolved under `path` and submitted to the job. */
+    itemCount: number;
+    /** The publish job receipt. */
+    job: {
+        id: string;
+        processedCount: number;
+        stateName: string;
+    };
+}
+/**
+ * Publish an item and all of its descendants in one job.
+ *
+ * Resolves every item under `path` via the Management API, then submits
+ * the whole set to the publish pipeline. Throws (`INPUT_INVALID`) when
+ * `path` resolves to no items. Composes `fetchItemMetadata` +
+ * `publishItems` so callers (CLI, MCP, embedding SDK) get the workflow
+ * rather than wiring the two raw calls themselves.
+ */
+export declare const publishItemSubtree: (environment: SitecoreApiClientOptions, path: string, options?: {
+    database?: string;
+    target?: string;
+}) => Promise<PublishItemSubtreeResult>;

package/dist/serialization/api/publish.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishItemSubtree = exports.fetchPublishingTargets = exports.checkPublishStatus = exports.publishItems = void 0;
+const errors_1 = require("../../shared/errors");
+const graphql_1 = require("./graphql");
+const field_filter_1 = require("../field-filter");
+const items_1 = require("./items");
+const publishMutation = `
+mutation($path: String, $languages: [String] , $itemIds : [String], $republish : Boolean, $target : String) {
+  publish(path: $path, languages: $languages, itemIds :$itemIds, republish :$republish, target :$target) {
+    id
+    processedCount
+    stateCode
+    stateName
+  }
+}`;
+const publishStatusQuery = `
+query($id: String)
+{
+  publishingStatus(id: $id)
+  {
+    id
+    processedCount
+    stateCode
+    stateName
+  }
+}`;
+const listTargetsQuery = `
+query {
+  listOfTargets
+}`;
+const publishItems = async (environment, itemIds, target, options) => {
+    const data = await (0, graphql_1.runGraphQL)(environment, publishMutation, { itemIds, target }, options);
+    return data.publish;
+};
+exports.publishItems = publishItems;
+const checkPublishStatus = async (environment, publishId, options) => {
+    const data = await (0, graphql_1.runGraphQL)(environment, publishStatusQuery, { id: publishId }, options);
+    return data.publishingStatus;
+};
+exports.checkPublishStatus = checkPublishStatus;
+const fetchPublishingTargets = async (environment, options) => {
+    const data = await (0, graphql_1.runGraphQL)(environment, listTargetsQuery, undefined, options);
+    return data.listOfTargets ?? [];
+};
+exports.fetchPublishingTargets = fetchPublishingTargets;
+/**
+ * Publish an item and all of its descendants in one job.
+ *
+ * Resolves every item under `path` via the Management API, then submits
+ * the whole set to the publish pipeline. Throws (`INPUT_INVALID`) when
+ * `path` resolves to no items. Composes `fetchItemMetadata` +
+ * `publishItems` so callers (CLI, MCP, embedding SDK) get the workflow
+ * rather than wiring the two raw calls themselves.
+ */
+const publishItemSubtree = async (environment, path, options = {}) => {
+    const database = options.database ?? "master";
+    const fieldFilter = (0, field_filter_1.createFieldFilterSet)([], []);
+    const metadata = await (0, items_1.fetchItemMetadata)(environment, database, path, "ItemAndDescendants", fieldFilter, false);
+    const itemIds = metadata.map((entry) => entry.id);
+    if (itemIds.length === 0) {
+        throw (0, errors_1.createScaiError)(`No items found under path '${path}' in database '${database}'.`, "INPUT_INVALID");
+    }
+    const job = await (0, exports.publishItems)(environment, itemIds, options.target);
+    return { path, database, target: options.target, itemCount: itemIds.length, job };
+};
+exports.publishItemSubtree = publishItemSubtree;

package/dist/serialization/api/roles.d.ts

@@ -0,0 +1,8 @@
+import type { SitecoreApiClientOptions } from "./types";
+import { RoleData } from "../types";
+import { GraphQLRequestOptions } from "./graphql";
+export declare const fetchRoles: (environment: SitecoreApiClientOptions, predicates: Array<{
+    domain: string;
+    pattern: string;
+}>, options?: GraphQLRequestOptions) => Promise<RoleData[]>;
+export declare const pushRoleCommands: (environment: SitecoreApiClientOptions, commands: unknown[], options?: GraphQLRequestOptions) => Promise<unknown[]>;

package/dist/serialization/api/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Public option shape for the Sitecore Management + Authoring GraphQL
+ * clients. Library callers construct one of these directly. The CLI
+ * passes its full `EnvironmentConfiguration` (which structurally
+ * satisfies this interface) — no per-call adapter.
+ *
+ * Why a structural subset and not the full config: `EnvironmentConfiguration`
+ * has 30+ fields covering deploy-token caching, recipe roots, allow-write
+ * gates, tenant identifiers, etc. — none of which the GraphQL transport
+ * uses. Library callers (orchestrators, MCP servers, tests) should
+ * construct only the auth + host bits they actually need.
+ *
+ * `host` is functionally required for any API call (every transport
+ * throws `INPUT_INVALID` when it's missing), but it stays optional in
+ * the type so this interface is satisfied by `EnvironmentConfiguration`
+ * — which has it optional because the config wizard may not have set
+ * it yet at construction time.
+ */
+import type { AutomationClientMetadata } from "../../config/types";
+export interface SitecoreApiClientOptions {
+    /** CM hostname (e.g. `https://xmc-org-env.sitecorecloud.io`). */
+    host?: string;
+    /** Sitecore organization id — used to resolve org-scoped credentials. */
+    organizationId?: string;
+    /** OAuth identity authority (e.g. `https://auth.sitecorecloud.io`). */
+    authority?: string;
+    /** OAuth client id. */
+    clientId?: string;
+    /** OAuth client secret (required for client-credentials flow). */
+    clientSecret?: string;
+    /**
+     * Non-secret metadata of the scai-minted env-scoped automation client.
+     * Carried through from `EnvironmentConfiguration.automationClient` so
+     * the auth layer can pair `automationClient.clientId` with the secret
+     * it reads from the OS keychain. Only `clientId` is used here.
+     */
+    automationClient?: AutomationClientMetadata;
+    /**
+     * `clientId` of the scai-minted org-scoped automation client — read
+     * from the root config's `orgClients[organizationId]` block. The org
+     * client lives at the root of the config, not on the env profile, so
+     * a caller that wants tier-3 (org-client) resolution must populate
+     * this from the resolved `RootConfiguration`.
+     */
+    orgClientId?: string;
+    /** OAuth audience. Defaults to `https://api.sitecorecloud.io`. */
+    audience?: string;
+    /** Pre-obtained access token. Bypasses OAuth flow entirely. */
+    accessToken?: string;
+    /** Pre-obtained refresh token. */
+    refreshToken?: string;
+    /** Additional refresh-token request parameters (rarely needed). */
+    refreshTokenParameters?: Record<string, string>;
+    /** Use client-credentials flow. Defaults to false; requires `clientSecret`. */
+    useClientCredentials?: boolean;
+    /**
+     * Cache acquired tokens in the OS keychain. Defaults to true.
+     * Has no effect when `name` is unset — caching is keyed by env name.
+     * Library callers that bring their own cache should pass
+     * `cacheAuthenticationToken: false`.
+     */
+    cacheAuthenticationToken?: boolean;
+    /** Environment name; used as the keychain cache key. */
+    name?: string;
+}

package/dist/serialization/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/serialization/api/users.d.ts

@@ -0,0 +1,8 @@
+import type { SitecoreApiClientOptions } from "./types";
+import { UserData } from "../types";
+import { GraphQLRequestOptions } from "./graphql";
+export declare const fetchUsers: (environment: SitecoreApiClientOptions, predicates: Array<{
+    domain: string;
+    pattern: string;
+}>, options?: GraphQLRequestOptions) => Promise<UserData[]>;
+export declare const pushUserCommands: (environment: SitecoreApiClientOptions, commands: unknown[], options?: GraphQLRequestOptions) => Promise<unknown[]>;

package/dist/serialization/commands.d.ts

@@ -45,4 +45,3 @@ export declare const buildCommandsForSubtree: (subtree: FilesystemTreeSpec, sour
 export declare const buildUpdateCommandData: (comparison: ItemComparisonResult, push: boolean) => UpdateCommandData[];
 export declare const enrichUpdateCommands: (commands: ItemCommand[], sourceData: Map<string, ItemData>, destinationData: Map<string, ItemData>, push: boolean) => void;
 export declare const enrichCreateCommands: (commands: ItemCommand[], sourceData: Map<string, ItemData>) => void;
-//# sourceMappingURL=commands.d.ts.map

package/dist/serialization/compare.d.ts

@@ -26,4 +26,3 @@ export type ItemComparisonResult = {
     changedVersions: ItemVersionComparisonResult[];
 };
 export declare const compareItems: (left: ItemData, right: ItemData) => ItemComparisonResult;
-//# sourceMappingURL=compare.d.ts.map

package/dist/serialization/context.d.ts

@@ -0,0 +1,25 @@
+import type { RootConfiguration, SerializationModuleConfiguration } from "../config/types";
+import { FilesystemTreeSpec } from "./tree-spec";
+/** Options for {@link loadConfigAndModules}. */
+export interface LoadSerializationModulesOptions {
+    /** Base directory for resolving `sitecoreai.cli.json`; defaults to cwd. */
+    config?: string;
+    /** Environment profile name; defaults to the config's default profile. */
+    environmentName?: string;
+    /** Module-namespace include filter. */
+    include?: string[];
+    /** Module-namespace exclude filter. */
+    exclude?: string[];
+}
+/**
+ * Resolve the root configuration for an environment and load every
+ * serialization module it references.
+ */
+export declare const loadConfigAndModules: (options: LoadSerializationModulesOptions) => Promise<{
+    root: RootConfiguration;
+    modules: SerializationModuleConfiguration[];
+}>;
+/** Group every module's subtrees by the database they target. */
+export declare const groupSubtreesByDatabase: (modules: SerializationModuleConfiguration[]) => Map<string, FilesystemTreeSpec[]>;
+/** Throw unless the environment is configured to allow writes. */
+export declare const ensureAllowWrite: (root: RootConfiguration, environmentName: string) => void;

package/dist/serialization/context.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAllowWrite = exports.groupSubtreesByDatabase = exports.loadConfigAndModules = void 0;
+/**
+ * Serialization context — root config + serialization-module loading,
+ * subtree grouping by database, and the write-consent guard.
+ *
+ * This is the substantive orchestration the CLI runners (`./tasks`) and
+ * MCP tools share. It is exported from the area barrel so an SDK
+ * consumer can load the same config + module set the CLI works against.
+ *
+ * Presentation-free: no logger, no stdout, no `process.exit`.
+ */
+const root_config_1 = require("../config/root-config");
+const modules_1 = require("../config/modules");
+const errors_1 = require("../shared/errors");
+/**
+ * Resolve the root configuration for an environment and load every
+ * serialization module it references.
+ */
+const loadConfigAndModules = async (options) => {
+    const configPath = options.config ?? process.cwd();
+    const rootFile = (0, root_config_1.readRootConfigurationFile)(configPath);
+    const envName = options.environmentName ?? rootFile.config.defaultEnvProfile;
+    const root = (0, root_config_1.readRootConfiguration)(configPath, envName);
+    const modules = await (0, modules_1.readSerializationModules)(root, options.include, options.exclude);
+    return { root, modules };
+};
+exports.loadConfigAndModules = loadConfigAndModules;
+/** Group every module's subtrees by the database they target. */
+const groupSubtreesByDatabase = (modules) => {
+    const map = new Map();
+    for (const module of modules) {
+        for (const subtree of module.items.includes) {
+            if (!map.has(subtree.database)) {
+                map.set(subtree.database, []);
+            }
+            map.get(subtree.database).push(subtree);
+        }
+    }
+    return map;
+};
+exports.groupSubtreesByDatabase = groupSubtreesByDatabase;
+/** Throw unless the environment is configured to allow writes. */
+const ensureAllowWrite = (root, environmentName) => {
+    const env = root.environments[environmentName];
+    if (!env?.allowWrite) {
+        const envKey = environmentName
+            .trim()
+            .toUpperCase()
+            .replace(/[^A-Z0-9]+/g, "_")
+            .replace(/^_+|_+$/g, "");
+        throw (0, errors_1.createScaiError)(`Environment ${environmentName} is not configured to allow writing data.`, "INPUT_INVALID", {
+            hint: `Set allowWrite in sitecoreai.cli.json, set SITECOREAI_ENV_${envKey}_ALLOW_WRITE=true, or pass --allow-write.`,
+        });
+    }
+};
+exports.ensureAllowWrite = ensureAllowWrite;

package/dist/serialization/field-filter.d.ts

@@ -4,4 +4,3 @@ export type FieldFilterSet = {
 };
 export declare const createFieldFilterSet: (rootExcluded: FieldFilter[], moduleExcluded: FieldFilter[]) => FieldFilterSet;
 export declare const filterFieldIds: (filterSet: FieldFilterSet) => string[];
-//# sourceMappingURL=field-filter.d.ts.map

package/dist/serialization/filesystem-store/constants.d.ts

@@ -1,3 +1,2 @@
 export declare const ROLES_FOLDER_SUFFIX = "_roles";
 export declare const USERS_FOLDER_SUFFIX = "_users";
-//# sourceMappingURL=constants.d.ts.map

package/dist/serialization/filesystem-store/items.d.ts

@@ -7,4 +7,3 @@ export declare const loadFilesystemItems: (subtrees: FilesystemTreeSpec[]) => Pr
 }>;
 export declare const writeItemToFilesystem: (pathProvider: FilesystemPathProvider, item: ItemData) => Promise<string>;
 export declare const removeItemFromFilesystem: (pathProvider: FilesystemPathProvider, item: ItemMetadata) => Promise<void>;
-//# sourceMappingURL=items.d.ts.map

package/dist/serialization/filesystem-store/items.js

@@ -46,7 +46,7 @@ exports.loadFilesystemItems = loadFilesystemItems;
 const writeItemToFilesystem = async (pathProvider, item) => {
     const targetPath = pathProvider.getPhysicalPathForItemPath(item.path, ".yml");
     if (!targetPath) {
-        throw (0, errors_1.createCliError)(`Unable to resolve file path for ${item.path}`, "INPUT_INVALID");
+        throw (0, errors_1.createScaiError)(`Unable to resolve file path for ${item.path}`, "INPUT_INVALID");
     }
     await promises_1.default.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
     const content = (0, yaml_1.writeItemYaml)(item);

package/dist/serialization/filesystem-store/roles.d.ts

@@ -1,6 +1,5 @@
 import { RoleData } from "../types";
-import { RootConfiguration, SerializationModuleConfiguration } from "../../config";
+import type { RootConfiguration, SerializationModuleConfiguration } from "../../config/types";
 export declare const readRolesFromFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration) => Promise<RoleData[]>;
 export declare const writeRoleToFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration, role: RoleData) => Promise<string>;
 export declare const removeRoleFromFilesystem: (rolePath?: string) => Promise<void>;
-//# sourceMappingURL=roles.d.ts.map

package/dist/serialization/filesystem-store/users.d.ts

@@ -1,6 +1,5 @@
 import { UserData } from "../types";
-import { RootConfiguration, SerializationModuleConfiguration } from "../../config";
+import type { RootConfiguration, SerializationModuleConfiguration } from "../../config/types";
 export declare const readUsersFromFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration) => Promise<UserData[]>;
 export declare const writeUserToFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration, user: UserData) => Promise<string>;
 export declare const removeUserFromFilesystem: (userPath?: string) => Promise<void>;
-//# sourceMappingURL=users.d.ts.map

package/dist/serialization/filesystem-store/utils.d.ts

@@ -1,2 +1 @@
 export declare const exists: (value: string) => Promise<boolean>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/serialization/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/serialization`.
+ *
+ * `./api/index.ts` is itself a curated, explicit barrel (zero `export *`)
+ * and stays the source of truth for the Sitecore Management + Authoring
+ * GraphQL client surface — it is re-exported wholesale. `./context` is a
+ * plain module, so its public symbols are enumerated explicitly below: a
+ * new intra-area `export` in `context.ts` must be added here deliberately
+ * to widen the SDK surface.
+ */
+export * from "./api";
+export { loadConfigAndModules, groupSubtreesByDatabase, ensureAllowWrite, type LoadSerializationModulesOptions, } from "./context";

package/dist/serialization/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/serialization`.
+ *
+ * `./api/index.ts` is itself a curated, explicit barrel (zero `export *`)
+ * and stays the source of truth for the Sitecore Management + Authoring
+ * GraphQL client surface — it is re-exported wholesale. `./context` is a
+ * plain module, so its public symbols are enumerated explicitly below: a
+ * new intra-area `export` in `context.ts` must be added here deliberately
+ * to widen the SDK surface.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAllowWrite = exports.groupSubtreesByDatabase = exports.loadConfigAndModules = void 0;
+__exportStar(require("./api"), exports);
+var context_1 = require("./context");
+Object.defineProperty(exports, "loadConfigAndModules", { enumerable: true, get: function () { return context_1.loadConfigAndModules; } });
+Object.defineProperty(exports, "groupSubtreesByDatabase", { enumerable: true, get: function () { return context_1.groupSubtreesByDatabase; } });
+Object.defineProperty(exports, "ensureAllowWrite", { enumerable: true, get: function () { return context_1.ensureAllowWrite; } });

package/dist/serialization/item-path.d.ts

@@ -29,4 +29,3 @@ export declare class ItemPathMatch implements ItemPathMatchLike {
     toPathString(): string;
     toString(): string;
 }
-//# sourceMappingURL=item-path.d.ts.map

package/dist/serialization/item-path.js

@@ -10,7 +10,7 @@ class ItemPath {
     }
     static fromPathString(pathString) {
         if (!pathString || !pathString.startsWith("/")) {
-            throw (0, errors_1.createCliError)(`Item path '${pathString}' did not start with /.`, "INPUT_INVALID");
+            throw (0, errors_1.createScaiError)(`Item path '${pathString}' did not start with /.`, "INPUT_INVALID");
         }
         const segments = pathString.split("/").filter(Boolean);
         return new ItemPath(segments, pathString.replace(/\/+$/, ""));
@@ -55,14 +55,14 @@ class ItemPath {
     }
     prepend(segment) {
         if (!segment || segment.includes("/")) {
-            throw (0, errors_1.createCliError)("Cannot prepend multiple segments.", "INPUT_INVALID");
+            throw (0, errors_1.createScaiError)("Cannot prepend multiple segments.", "INPUT_INVALID");
         }
         return new ItemPath([segment, ...this.segments]);
     }
     concatenate(segment) {
         if (typeof segment === "string") {
             if (!segment || segment.includes("/")) {
-                throw (0, errors_1.createCliError)("Cannot concatenate multiple segments using string.", "INPUT_INVALID");
+                throw (0, errors_1.createScaiError)("Cannot concatenate multiple segments using string.", "INPUT_INVALID");
             }
             return new ItemPath([...this.segments, segment]);
         }

package/dist/serialization/path-provider.d.ts

@@ -9,4 +9,3 @@ export declare class FilesystemPathProvider {
     toString(): string;
     private invokeUnique;
 }
-//# sourceMappingURL=path-provider.d.ts.map

package/dist/serialization/path-provider.js

@@ -89,7 +89,7 @@ class SubtreeFilesystemPathProvider {
     }
     getPhysicalPathForItemPath(itemPath, extension) {
         if (!extension.startsWith(".")) {
-            throw (0, errors_1.createCliError)("Extension must start with a period.", "INPUT_INVALID");
+            throw (0, errors_1.createScaiError)("Extension must start with a period.", "INPUT_INVALID");
         }
         const childPath = this.getChildrenPathForItemPath(itemPath);
         if (!childPath) {
@@ -211,7 +211,7 @@ class SubtreeFilesystemPathProvider {
             return relativePath;
         }
         if (maxLength < 16) {
-            throw (0, errors_1.createCliError)(`MaxRelativePathLength ${maxLength} is below minimum value of 16.`, "CONFIG_INVALID");
+            throw (0, errors_1.createScaiError)(`MaxRelativePathLength ${maxLength} is below minimum value of 16.`, "CONFIG_INVALID");
         }
         let currentPath = relativeItemPath;
         const targetMultiple = Math.floor(relativeItemPath.pathLength / maxLength);
@@ -223,7 +223,7 @@ class SubtreeFilesystemPathProvider {
             }
         }
         if (!currentPath || currentPath.count === 0) {
-            throw (0, errors_1.createCliError)(`The path ${relativeItemPath} could not be stored because its length could not be reduced below the maximum path length ${maxLength}.`, "INPUT_INVALID");
+            throw (0, errors_1.createScaiError)(`The path ${relativeItemPath} could not be stored because its length could not be reduced below the maximum path length ${maxLength}.`, "INPUT_INVALID");
         }
         const relative = relativeItemPath.createRelativePathFrom(currentPath);
         if (!relative) {
@@ -258,7 +258,7 @@ class FilesystemPathProvider {
         for (const subtree of this.subtrees.getAncestorAndSelfPathData(itemPath)) {
             const subtreeResult = fn(subtree);
             if (subtreeResult != null && result != null) {
-                throw (0, errors_1.createCliError)(`The item path ${itemPath} was included in multiple places. Found valid file paths within these modules: ${resultFoundOn} and ${subtree}`, "CONFIG_INVALID");
+                throw (0, errors_1.createScaiError)(`The item path ${itemPath} was included in multiple places. Found valid file paths within these modules: ${resultFoundOn} and ${subtree}`, "CONFIG_INVALID");
             }
             if (subtreeResult != null) {
                 resultFoundOn = subtree;

package/dist/serialization/signature.d.ts

@@ -1,4 +1,3 @@
 import { ItemData } from "./types";
 export declare const createDataSignatureBase: (item: ItemData, forceBlobRestore?: boolean) => string;
 export declare const createSignature: (signatureBase: string | null) => string | null;
-//# sourceMappingURL=signature.d.ts.map

package/dist/serialization/tasks/diff.d.ts

@@ -1,3 +1,2 @@
 import type { DiffOptions } from "./types";
 export declare const runDiff: (options: DiffOptions) => Promise<void>;
-//# sourceMappingURL=diff.d.ts.map