sb-mig 5.6.0-beta.1 → 5.6.0-beta.2

package/dist/api-v2/presets/index.d.ts

@@ -0,0 +1,13 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllPresets(client: ApiClient): Promise<any>;
+export declare function getPreset(client: ApiClient, presetId: string): Promise<any>;
+export declare function createPreset(client: ApiClient, preset: any): Promise<any>;
+export declare function updatePreset(client: ApiClient, preset: any): Promise<any>;
+export declare function updatePresets(client: ApiClient, args: {
+    presets: any[];
+    spaceId: string;
+    options?: {
+        publish?: boolean;
+    };
+}): Promise<any>;
+export declare function getComponentPresets(client: ApiClient, componentName: string): Promise<any>;

package/dist/api-v2/presets/index.js

@@ -0,0 +1,25 @@
+import { getComponentPresets as apiGetComponentPresets } from "../../api/presets/componentPresets.js";
+import { getAllPresets as apiGetAllPresets, getPreset as apiGetPreset, createPreset as apiCreatePreset, updatePreset as apiUpdatePreset, updatePresets as apiUpdatePresets, } from "../../api/presets/presets.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function getAllPresets(client) {
+    return await apiGetAllPresets(toRequestConfig(client));
+}
+export async function getPreset(client, presetId) {
+    return await apiGetPreset({ presetId }, toRequestConfig(client));
+}
+export async function createPreset(client, preset) {
+    return await apiCreatePreset(preset, toRequestConfig(client));
+}
+export async function updatePreset(client, preset) {
+    return await apiUpdatePreset({ p: preset }, toRequestConfig(client));
+}
+export async function updatePresets(client, args) {
+    return await apiUpdatePresets({
+        presets: args.presets,
+        spaceId: args.spaceId,
+        options: args.options ?? {},
+    }, toRequestConfig(client));
+}
+export async function getComponentPresets(client, componentName) {
+    return await apiGetComponentPresets(componentName, toRequestConfig(client));
+}

package/dist/api-v2/requestConfig.d.ts

@@ -0,0 +1,5 @@
+import type { ApiClient } from "./client.js";
+import type { RequestBaseConfig } from "../api/utils/request.js";
+export declare function toRequestConfig(client: ApiClient, overrides?: Partial<Omit<RequestBaseConfig, "sbApi">> & {
+    spaceId?: string;
+}): RequestBaseConfig;

package/dist/api-v2/requestConfig.js

@@ -0,0 +1,34 @@
+export function toRequestConfig(client, overrides) {
+    return {
+        spaceId: overrides?.spaceId ?? client.spaceId,
+        sbApi: client.sbApi,
+        oauthToken: overrides?.oauthToken ?? client.config.oauthToken,
+        accessToken: overrides?.accessToken ?? client.config.accessToken,
+        storyblokApiUrl: overrides?.storyblokApiUrl,
+        storyblokDeliveryApiUrl: overrides?.storyblokDeliveryApiUrl,
+        storyblokGraphqlApiUrl: overrides?.storyblokGraphqlApiUrl,
+        schemaFileExt: overrides?.schemaFileExt,
+        datasourceExt: overrides?.datasourceExt,
+        rolesExt: overrides?.rolesExt,
+        storiesExt: overrides?.storiesExt,
+        migrationConfigExt: overrides?.migrationConfigExt,
+        sbmigWorkingDirectory: overrides?.sbmigWorkingDirectory,
+        presetsBackupDirectory: overrides?.presetsBackupDirectory,
+        storiesBackupDirectory: overrides?.storiesBackupDirectory,
+        componentsDirectories: overrides?.componentsDirectories,
+        flushCache: overrides?.flushCache,
+        cacheDir: overrides?.cacheDir,
+        debug: overrides?.debug,
+        rateLimit: overrides?.rateLimit,
+        openaiToken: overrides?.openaiToken,
+        boilerplateSpaceId: overrides?.boilerplateSpaceId,
+        schemaType: overrides?.schemaType,
+        awsBucketData: overrides?.awsBucketData,
+        metadataSelection: overrides?.metadataSelection,
+        contentHubOriginUrl: overrides?.contentHubOriginUrl,
+        contentHubAuthorizationToken: overrides?.contentHubAuthorizationToken,
+        resolvers: overrides?.resolvers,
+        advancedResolvers: overrides?.advancedResolvers,
+        storyblokComponentsLocalDirectory: overrides?.storyblokComponentsLocalDirectory,
+    };
+}

package/dist/api-v2/roles/index.d.ts

@@ -0,0 +1,5 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllRoles(client: ApiClient): Promise<any>;
+export declare function getRole(client: ApiClient, roleName: string): Promise<any>;
+export declare function createRole(client: ApiClient, role: any): Promise<any>;
+export declare function updateRole(client: ApiClient, role: any): Promise<any>;

package/dist/api-v2/roles/index.js

@@ -0,0 +1,35 @@
+import { getAllItemsWithPagination } from "../../api/utils/request.js";
+export async function getAllRoles(client) {
+    const spaceId = client.spaceId;
+    return getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => client.sbApi.get(`spaces/${spaceId}/space_roles/`, {
+            per_page,
+            page,
+        }),
+        params: {
+            spaceId,
+        },
+        itemsKey: "space_roles",
+    });
+}
+export async function getRole(client, roleName) {
+    const roles = await getAllRoles(client);
+    const match = roles.filter((r) => r.role === roleName);
+    if (Array.isArray(match) && match.length === 0)
+        return false;
+    return match;
+}
+export async function createRole(client, role) {
+    const spaceId = client.spaceId;
+    return client.sbApi
+        .post(`spaces/${spaceId}/space_roles/`, { space_role: role })
+        .then((res) => res.data);
+}
+export async function updateRole(client, role) {
+    const spaceId = client.spaceId;
+    return client.sbApi
+        .put(`spaces/${spaceId}/space_roles/${role.id}`, {
+        space_role: role,
+    })
+        .then((res) => res.data);
+}

package/dist/api-v2/spaces/index.d.ts

@@ -0,0 +1,7 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllSpaces(client: ApiClient): Promise<any>;
+export declare function getSpace(client: ApiClient, spaceId: string): Promise<any>;
+export declare function updateSpace(client: ApiClient, args: {
+    spaceId: string;
+    params: Record<string, any>;
+}): Promise<any>;

package/dist/api-v2/spaces/index.js

@@ -0,0 +1,11 @@
+import { getAllSpaces as apiGetAllSpaces, getSpace as apiGetSpace, updateSpace as apiUpdateSpace, } from "../../api/spaces/spaces.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function getAllSpaces(client) {
+    return await apiGetAllSpaces(toRequestConfig(client));
+}
+export async function getSpace(client, spaceId) {
+    return await apiGetSpace({ spaceId }, toRequestConfig(client));
+}
+export async function updateSpace(client, args) {
+    return await apiUpdateSpace(args, toRequestConfig(client));
+}

package/dist/api-v2/stories/index.d.ts

@@ -0,0 +1,34 @@
+import type { ApiClient } from "../client.js";
+import type { CopyProgress, CopyResult, StoryTreeNode } from "./types.js";
+import type { ExtendedISbStoriesParams } from "../../api/stories/stories.types.js";
+/**
+ * Get all stories from a space
+ */
+export declare function getAllStories(client: ApiClient, options?: ExtendedISbStoriesParams): Promise<any[]>;
+/**
+ * Get a single story by ID
+ */
+export declare function getStoryById(client: ApiClient, storyId: number | string): Promise<any>;
+/**
+ * Get a story by slug
+ */
+export declare function getStoryBySlug(client: ApiClient, slug: string): Promise<any>;
+/**
+ * Create a story in a space
+ */
+export declare function createStory(client: ApiClient, content: any): Promise<any>;
+/**
+ * Fetch all stories and build a tree structure
+ */
+export declare function fetchStories(client: ApiClient, options?: ExtendedISbStoriesParams): Promise<{
+    stories: any[];
+    tree: StoryTreeNode[];
+    total: number;
+}>;
+/**
+ * Copy stories from source space to target space
+ */
+export declare function copyStories(sourceClient: ApiClient, targetClient: ApiClient, options: {
+    storyIds: number[];
+    destinationParentId?: number | null;
+}, onProgress?: (progress: CopyProgress) => void): Promise<CopyResult>;

package/dist/api-v2/stories/index.js

@@ -0,0 +1,172 @@
+import { getAllStories as apiGetAllStories, getStoryById as apiGetStoryById, getStoryBySlug as apiGetStoryBySlug, createStory as apiCreateStory, } from "../../api/stories/stories.js";
+import { toRequestConfig } from "../requestConfig.js";
+/**
+ * Build a tree structure from flat story list
+ */
+function buildTree(stories) {
+    const storyMap = new Map();
+    // First pass: create all nodes
+    for (const storyData of stories) {
+        const story = storyData.story || storyData;
+        storyMap.set(story.id, {
+            id: story.id,
+            name: story.name,
+            slug: story.slug,
+            full_slug: story.full_slug,
+            is_folder: story.is_folder,
+            is_startpage: story.is_startpage,
+            parent_id: story.parent_id,
+            children: [],
+            story,
+        });
+    }
+    // Second pass: build tree structure
+    const rootNodes = [];
+    for (const storyData of stories) {
+        const story = storyData.story || storyData;
+        const node = storyMap.get(story.id);
+        if (story.parent_id === null || story.parent_id === 0) {
+            rootNodes.push(node);
+        }
+        else {
+            const parent = storyMap.get(story.parent_id);
+            if (parent) {
+                parent.children.push(node);
+            }
+            else {
+                rootNodes.push(node);
+            }
+        }
+    }
+    // Sort children
+    const sortNodes = (nodes) => {
+        nodes.sort((a, b) => {
+            if (a.is_folder && !b.is_folder)
+                return -1;
+            if (!a.is_folder && b.is_folder)
+                return 1;
+            if (a.story.position !== b.story.position) {
+                return a.story.position - b.story.position;
+            }
+            return a.name.localeCompare(b.name);
+        });
+        for (const node of nodes) {
+            if (node.children.length > 0) {
+                sortNodes(node.children);
+            }
+        }
+    };
+    sortNodes(rootNodes);
+    return rootNodes;
+}
+/**
+ * Get all stories from a space
+ */
+export async function getAllStories(client, options) {
+    const config = toRequestConfig(client);
+    return await apiGetAllStories({ options }, config);
+}
+/**
+ * Get a single story by ID
+ */
+export async function getStoryById(client, storyId) {
+    const config = toRequestConfig(client);
+    return await apiGetStoryById(String(storyId), config);
+}
+/**
+ * Get a story by slug
+ */
+export async function getStoryBySlug(client, slug) {
+    const config = toRequestConfig(client);
+    return await apiGetStoryBySlug(slug, config);
+}
+/**
+ * Create a story in a space
+ */
+export async function createStory(client, content) {
+    const config = toRequestConfig(client);
+    return await apiCreateStory(content, config);
+}
+/**
+ * Fetch all stories and build a tree structure
+ */
+export async function fetchStories(client, options) {
+    const stories = await getAllStories(client, options);
+    const tree = buildTree(stories);
+    return {
+        stories,
+        tree,
+        total: stories.length,
+    };
+}
+/**
+ * Copy stories from source space to target space
+ */
+export async function copyStories(sourceClient, targetClient, options, onProgress) {
+    const errors = [];
+    let copiedCount = 0;
+    // Fetch all stories with their full content
+    const storiesToCopy = [];
+    for (let i = 0; i < options.storyIds.length; i++) {
+        const storyId = options.storyIds[i];
+        if (storyId === undefined)
+            continue;
+        onProgress?.({
+            current: i + 1,
+            total: options.storyIds.length,
+            currentStory: `Fetching story ${storyId}...`,
+            status: "copying",
+        });
+        try {
+            const storyData = await getStoryById(sourceClient, storyId);
+            storiesToCopy.push(storyData);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to fetch story ${storyId}: ${errorMsg}`);
+        }
+    }
+    // Build tree from selected stories
+    const tree = buildTree(storiesToCopy);
+    // Recursive function to create stories maintaining hierarchy
+    const createInOrder = async (nodes, newParentId) => {
+        for (const node of nodes) {
+            onProgress?.({
+                current: copiedCount + 1,
+                total: storiesToCopy.length,
+                currentStory: node.name,
+                status: "copying",
+            });
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { id, uuid, created_at, updated_at, ...storyData } = node.story;
+                const newStory = await createStory(targetClient, {
+                    ...storyData,
+                    parent_id: newParentId,
+                });
+                copiedCount++;
+                // Recursively create children
+                if (node.children.length > 0) {
+                    await createInOrder(node.children, newStory.story.id);
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                errors.push(`Failed to create "${node.name}": ${errorMsg}`);
+            }
+        }
+    };
+    // Start creating from root nodes
+    await createInOrder(tree, options.destinationParentId ?? null);
+    onProgress?.({
+        current: copiedCount,
+        total: storiesToCopy.length,
+        currentStory: "Complete",
+        status: errors.length > 0 ? "error" : "done",
+    });
+    return {
+        success: errors.length === 0,
+        copiedCount,
+        errors,
+    };
+}

package/dist/api-v2/stories/types.d.ts

@@ -0,0 +1,28 @@
+export interface CopyProgress {
+    current: number;
+    total: number;
+    currentStory: string;
+    status: "pending" | "copying" | "done" | "error";
+    error?: string;
+}
+export interface CopyResult {
+    success: boolean;
+    copiedCount: number;
+    errors: string[];
+}
+export interface StoryTreeNode {
+    id: number;
+    name: string;
+    slug: string;
+    full_slug: string;
+    is_folder: boolean;
+    is_startpage: boolean;
+    parent_id: number | null;
+    children: StoryTreeNode[];
+    story: any;
+}
+export interface FetchStoriesResult {
+    stories: any[];
+    tree: StoryTreeNode[];
+    total: number;
+}

package/dist/api-v2/stories/types.js

@@ -0,0 +1 @@
+export {};

package/dist/api-v2/sync/index.d.ts

@@ -0,0 +1,24 @@
+import type { ApiClient } from "../client.js";
+import type { SyncProgressCallback, SyncResult } from "./types.js";
+export declare function syncComponents(client: ApiClient, args: {
+    components: any[];
+    presets?: boolean;
+    ssot?: boolean;
+    dryRun?: boolean;
+    onProgress?: SyncProgressCallback;
+}): Promise<SyncResult>;
+export declare function syncDatasources(client: ApiClient, args: {
+    datasources: any[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;
+export declare function syncRoles(client: ApiClient, args: {
+    roles: any[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;
+export declare function syncPlugins(client: ApiClient, args: {
+    plugins: {
+        name: string;
+        body: string;
+    }[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;

package/dist/api-v2/sync/index.js

@@ -0,0 +1,109 @@
+import { syncComponentsData } from "../../api/components/components.sync.js";
+import { syncDatasourcesData } from "../../api/datasources/datasources.js";
+import { syncPluginsData } from "../../api/plugins/plugins.js";
+import { syncRolesData } from "../../api/roles/roles.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function syncComponents(client, args) {
+    const presets = args.presets ?? false;
+    if (args.dryRun) {
+        // minimal dry-run: compare names against remote
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/components/`, {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.components?.map((c) => c.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const c of args.components) {
+            const name = String(c?.name ?? "unknown");
+            if (!c?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(c.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await syncComponentsData({
+        components: args.components,
+        presets,
+        ssot: args.ssot,
+        onProgress: args.onProgress,
+    }, toRequestConfig(client)));
+}
+export async function syncDatasources(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/datasources/`);
+        const remoteNames = new Set(remote.data?.datasources?.map((d) => d.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const d of args.datasources) {
+            const name = String(d?.name ?? "unknown");
+            if (!d?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(d.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await syncDatasourcesData({ datasources: args.datasources }, toRequestConfig(client)));
+}
+export async function syncRoles(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/space_roles/`, {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.space_roles?.map((r) => r.role) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const r of args.roles) {
+            const name = String(r?.role ?? "unknown");
+            if (!r?.role) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(r.role))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await syncRolesData({ roles: args.roles }, toRequestConfig(client)));
+}
+export async function syncPlugins(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get("field_types", {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.field_types?.map((p) => p.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const p of args.plugins) {
+            const name = String(p?.name ?? "unknown");
+            if (!p?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(p.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await syncPluginsData({ plugins: args.plugins }, toRequestConfig(client)));
+}

package/dist/api-v2/sync/types.d.ts

@@ -0,0 +1 @@
+export type { SyncError, SyncResult, SyncProgressEvent, SyncProgressCallback, } from "../../api/sync/sync.types.js";

package/dist/api-v2/sync/types.js

@@ -0,0 +1 @@
+export {};

package/dist/api-v2/test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple test function with no dependencies to verify ESM/CJS interop
+ */
+export declare function testConnection(): {
+    success: boolean;
+    message: string;
+    timestamp: string;
+};
+/**
+ * Async test function to verify async imports work
+ */
+export declare function testAsyncConnection(): Promise<{
+    success: boolean;
+    message: string;
+}>;

package/dist/api-v2/test.js

@@ -0,0 +1,21 @@
+/**
+ * Simple test function with no dependencies to verify ESM/CJS interop
+ */
+export function testConnection() {
+    return {
+        success: true,
+        message: "sb-mig api-v2 connection successful!",
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Async test function to verify async imports work
+ */
+export async function testAsyncConnection() {
+    // Simulate a small delay
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return {
+        success: true,
+        message: "sb-mig api-v2 async connection successful!",
+    };
+}

package/dist/cli/commands/backup.js

@@ -1,10 +1,11 @@
 import { managementApi } from "../../api/managementApi.js";
 import { backupStories } from "../../api/stories/backup.js";
 import storyblokConfig from "../../config/config.js";
-import { createAndSaveToFile } from "../../utils/files.js";
+import { createAndSaveToFile, getPackageJson } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
-import { extractFields, getPackageJson, isItFactory, unpackOne, } from "../../utils/main.js";
+import { extractFields } from "../../utils/object-utils.js";
 import { apiConfig } from "../api-config.js";
+import { isItFactory, unpackOne } from "../utils/cli-utils.js";
 const BACKUP_COMMANDS = {
     components: "components",
     stories: "stories",
@@ -276,7 +277,10 @@ export const backup = async (props) => {
                                 filename: `${component.name}.presets.sb`,
                                 res: { allPresets: res, ...metadata },
                                 folder: storyblokConfig.presetsBackupDirectory,
-                            }, { ...apiConfig, sbmigWorkingDirectory: "." });
+                            }, {
+                                ...apiConfig,
+                                sbmigWorkingDirectory: ".",
+                            });
                         }
                     })
                         .catch((err) => {

package/dist/cli/commands/copy.js

@@ -1,8 +1,8 @@
 import { managementApi } from "../../api/managementApi.js";
 import { createTree, traverseAndCreate } from "../../api/stories/tree.js";
 import Logger from "../../utils/logger.js";
-import { getSourceSpace, getTargetSpace, getWhat, getWhere, } from "../../utils/others.js";
 import { apiConfig } from "../api-config.js";
+import { getSourceSpace, getTargetSpace, getWhat, getWhere, } from "../utils/cli-utils.js";
 const COPY_COMMANDS = {
     stories: "stories",
 };
@@ -19,7 +19,7 @@ const decideStrategy = async (args) => {
     const { what, sourceSpace } = args;
     // Check if path ends with /* for recursive folder strategy
     if (what.endsWith("/*")) {
-        const folderPath = what.slice(0, -2); // Remove /* from the end
+        const folderPath = what.slice(0, -2); // Remove /* from the endcurso
         const entryStory = await managementApi.stories.getStoryBySlug(folderPath, {
             ...apiConfig,
             spaceId: sourceSpace,

package/dist/cli/commands/migrate.js

@@ -3,10 +3,9 @@ import { managementApi } from "../../api/managementApi.js";
 import { backupStories } from "../../api/stories/backup.js";
 import { createAndSaveToFile } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
-import { isItFactory, unpackElements } from "../../utils/main.js";
-import { getFrom, getTo } from "../../utils/others.js";
 import { apiConfig } from "../api-config.js";
 import { askForConfirmation } from "../helpers.js";
+import { isItFactory, unpackElements, getFrom, getTo, } from "../utils/cli-utils.js";
 const MIGRATE_COMMANDS = {
     content: "content",
     presets: "presets",

package/dist/cli/commands/migrations.js

@@ -1,8 +1,8 @@
 import path from "path";
-import { readFile } from "../../utils/files.js";
+import { readFile, getFileContentWithRequire, getFilesContentWithRequire, } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
-import { getFileContentWithRequire, getFilesContentWithRequire, isItFactory, } from "../../utils/main.js";
 import { preselectMigrations } from "../../utils/migrations.js";
+import { isItFactory } from "../utils/cli-utils.js";
 import { discoverVersionMapping, LOOKUP_TYPE, SCOPE, } from "../utils/discover.js";
 const MIGRATIONS_COMMANDS = {
     recognize: "recognize",

package/dist/cli/commands/remove.js

@@ -1,8 +1,8 @@
 import { managementApi } from "../../api/managementApi.js";
 import { removeAllComponents, removeSpecifiedComponents, } from "../../api/migrate.js";
 import Logger from "../../utils/logger.js";
-import { unpackElements } from "../../utils/main.js";
 import { apiConfig } from "../api-config.js";
+import { unpackElements } from "../utils/cli-utils.js";
 const REMOVE_COMMANDS = {
     story: "story",
     components: "components",

package/dist/cli/commands/revert.js

@@ -1,9 +1,9 @@
 import { managementApi } from "../../api/managementApi.js";
+import { getFilesContentWithRequire } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
-import { getFilesContentWithRequire, isItFactory } from "../../utils/main.js";
-import { getFrom, getTo } from "../../utils/others.js";
 import { apiConfig } from "../api-config.js";
 import { askForConfirmation } from "../helpers.js";
+import { isItFactory, getFrom, getTo } from "../utils/cli-utils.js";
 import { discoverStories, LOOKUP_TYPE, SCOPE } from "../utils/discover.js";
 const REVERT_COMMANDS = {
     content: "content",