@slats/claude-assets-sync 0.0.1 → 0.0.2

package/dist/utils/nameTransform.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Name transformation utilities for Claude assets synchronization
+ * Handles conversion between package names and flat file naming conventions
+ */
+import { packageNameToPrefix as packageNameToPrefixUtil } from './packageName';
+/**
+ * Converts kebab-case string to camelCase
+ * All hyphens are removed and the following character is capitalized
+ *
+ * @param str - Input string in kebab-case format
+ * @returns String in camelCase format
+ *
+ * @example
+ * ```ts
+ * kebabToCamel('schema-form') // 'schemaForm'
+ * kebabToCamel('schema-form-plugin') // 'schemaFormPlugin'
+ * kebabToCamel('my-long-name') // 'myLongName'
+ * ```
+ */
+export declare function kebabToCamel(str: string): string;
+/**
+ * Converts a scoped package name to a flat prefix
+ * @deprecated Import from './packageName' instead
+ * @param packageName - Scoped package name (e.g., '@canard/schema-form')
+ * @returns Flat prefix (e.g., 'canard-schemaForm')
+ *
+ * @example
+ * ```ts
+ * packageNameToPrefix('@canard/schema-form') // 'canard-schemaForm'
+ * packageNameToPrefix('@canard/schema-form-plugin') // 'canard-schemaFormPlugin'
+ * packageNameToPrefix('@winglet/react-utils') // 'winglet-reactUtils'
+ * packageNameToPrefix('@lerx/promise-modal') // 'lerx-promiseModal'
+ * ```
+ */
+export declare const packageNameToPrefix: typeof packageNameToPrefixUtil;
+/**
+ * Creates a flat file name by combining prefix and original file name
+ *
+ * @param prefix - Package prefix (e.g., 'canard-schemaForm')
+ * @param fileName - Original file name (e.g., 'guide.md')
+ * @returns Flat file name (e.g., 'canard-schemaForm_guide.md')
+ *
+ * @example
+ * ```ts
+ * toFlatFileName('canard-schemaForm', 'guide.md') // 'canard-schemaForm_guide.md'
+ * toFlatFileName('winglet-reactUtils', 'README.md') // 'winglet-reactUtils_README.md'
+ * toFlatFileName('lerx-promiseModal', 'api/types.md') // 'lerx-promiseModal_api_types.md'
+ * ```
+ */
+export declare function toFlatFileName(prefix: string, fileName: string): string;
+/**
+ * Parses a flat file name back into prefix and original file name
+ * Returns null if the file name doesn't match the expected pattern
+ *
+ * @param flatName - Flat file name (e.g., 'canard-schemaForm_guide.md')
+ * @returns Object with prefix and original name, or null if invalid
+ *
+ * @example
+ * ```ts
+ * parseFlatFileName('canard-schemaForm_guide.md')
+ * // { prefix: 'canard-schemaForm', original: 'guide.md' }
+ *
+ * parseFlatFileName('winglet-reactUtils_README.md')
+ * // { prefix: 'winglet-reactUtils', original: 'README.md' }
+ *
+ * parseFlatFileName('lerx-promiseModal_api_types.md')
+ * // { prefix: 'lerx-promiseModal', original: 'api/types.md' }
+ *
+ * parseFlatFileName('invalid-name.md')
+ * // null (no underscore separator)
+ * ```
+ */
+export declare function parseFlatFileName(flatName: string): {
+    prefix: string;
+    original: string;
+} | null;

package/dist/utils/nameTransform.mjs

@@ -0,0 +1,9 @@
+import { packageNameToPrefix as packageNameToPrefix$1 } from './packageName.mjs';
+
+const packageNameToPrefix = packageNameToPrefix$1;
+function toFlatFileName(prefix, fileName) {
+    const flatFileName = fileName.replace(/[/\\]/g, '_');
+    return `${prefix}_${flatFileName}`;
+}
+
+export { packageNameToPrefix, toFlatFileName };

package/dist/utils/package.cjs

@@ -1,16 +1,14 @@
 'use strict';
 
 var node_child_process = require('node:child_process');
-var node_fs = require('node:fs');
-var node_path = require('node:path');
+var fs = require('node:fs');
+var path = require('node:path');
+var constants = require('../core/constants.cjs');
 
-const GITHUB_HTTPS_URL_PATTERN = /https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/;
-const GITHUB_SSH_URL_PATTERN = /git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/;
-const GITHUB_SHORTHAND_PATTERN = /^github:([^/]+)\/([^/]+)$/;
 const readPackageJson = (packageName, cwd = process.cwd()) => {
     try {
-        const packageJsonPath = node_path.join(cwd, 'node_modules', packageName, 'package.json');
-        const content = node_fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJsonPath = path.join(cwd, 'node_modules', packageName, 'package.json');
+        const content = fs.readFileSync(packageJsonPath, 'utf-8');
         const json = JSON.parse(content);
         if (!json.name || !json.version || !json.repository)
             return null;
@@ -29,21 +27,21 @@ const parseGitHubRepo = (repository) => {
     if (!repository || typeof repository.url !== 'string')
         return null;
     const url = repository.url;
-    const httpsMatch = url.match(GITHUB_HTTPS_URL_PATTERN);
+    const httpsMatch = url.match(constants.FS_PATTERNS.GITHUB_HTTPS_URL);
     if (httpsMatch)
         return {
             owner: httpsMatch[1],
             repo: httpsMatch[2],
             directory: repository.directory,
         };
-    const sshMatch = url.match(GITHUB_SSH_URL_PATTERN);
+    const sshMatch = url.match(constants.FS_PATTERNS.GITHUB_SSH_URL);
     if (sshMatch)
         return {
             owner: sshMatch[1],
             repo: sshMatch[2],
             directory: repository.directory,
         };
-    const shorthandMatch = url.match(GITHUB_SHORTHAND_PATTERN);
+    const shorthandMatch = url.match(constants.FS_PATTERNS.GITHUB_SHORTHAND);
     if (shorthandMatch)
         return {
             owner: shorthandMatch[1],
@@ -70,10 +68,10 @@ const findGitRoot = (cwd = process.cwd()) => {
 const findWorkspaceRoot = (startDir = process.cwd()) => {
     let currentDir = startDir;
     while (currentDir !== '/') {
-        const packageJsonPath = node_path.join(currentDir, 'package.json');
-        if (node_fs.existsSync(packageJsonPath)) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
             try {
-                const content = node_fs.readFileSync(packageJsonPath, 'utf-8');
+                const content = fs.readFileSync(packageJsonPath, 'utf-8');
                 const json = JSON.parse(content);
                 if (json.workspaces)
                     return currentDir;
@@ -81,7 +79,7 @@ const findWorkspaceRoot = (startDir = process.cwd()) => {
             catch {
             }
         }
-        currentDir = node_path.dirname(currentDir);
+        currentDir = path.dirname(currentDir);
     }
     return null;
 };
@@ -105,7 +103,7 @@ const getWorkspaceList = (workspaceRoot) => {
 const findWorkspaceLocation = (packageName, workspaceRoot) => {
     const workspaces = getWorkspaceList(workspaceRoot);
     const workspace = workspaces.find((ws) => ws.name === packageName);
-    return workspace ? node_path.join(workspaceRoot, workspace.location) : null;
+    return workspace ? path.join(workspaceRoot, workspace.location) : null;
 };
 const readLocalPackageJson = (packageName, cwd = process.cwd()) => {
     try {
@@ -115,8 +113,8 @@ const readLocalPackageJson = (packageName, cwd = process.cwd()) => {
         const packageLocation = findWorkspaceLocation(packageName, workspaceRoot);
         if (!packageLocation)
             return null;
-        const packageJsonPath = node_path.join(packageLocation, 'package.json');
-        const content = node_fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJsonPath = path.join(packageLocation, 'package.json');
+        const content = fs.readFileSync(packageJsonPath, 'utf-8');
         const json = JSON.parse(content);
         if (!json.name || !json.version || !json.repository)
             return null;
@@ -131,12 +129,19 @@ const readLocalPackageJson = (packageName, cwd = process.cwd()) => {
         return null;
     }
 };
+function getAssetTypes(config) {
+    if (!config.assets) {
+        return Array.from(constants.DEFAULT_ASSET_TYPES);
+    }
+    return Object.keys(config.assets);
+}
 
 exports.buildAssetPath = buildAssetPath;
 exports.buildVersionTag = buildVersionTag;
 exports.findGitRoot = findGitRoot;
 exports.findWorkspaceLocation = findWorkspaceLocation;
 exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.getAssetTypes = getAssetTypes;
 exports.getWorkspaceList = getWorkspaceList;
 exports.parseGitHubRepo = parseGitHubRepo;
 exports.readLocalPackageJson = readLocalPackageJson;

package/dist/utils/package.d.ts

@@ -1,4 +1,5 @@
 import type { GitHubRepoInfo, PackageInfo, WorkspaceInfo } from './types';
+export { getAssetStructure } from '../core/assetStructure';
 /**
  * Read package.json from node_modules
  * @param packageName - Package name (e.g., "@canard/schema-form")
@@ -64,3 +65,27 @@ export declare const findWorkspaceLocation: (packageName: string, workspaceRoot:
  * @returns PackageInfo or null if not found
  */
 export declare const readLocalPackageJson: (packageName: string, cwd?: string) => PackageInfo | null;
+/**
+ * Parse assets configuration from package.json with defaults
+ * @param config - ClaudeConfig from package.json
+ * @returns Normalized AssetsConfig with defaults
+ */
+export declare function parseAssetsConfig(config: {
+    assetPath: string;
+    assets?: Record<string, {
+        structure: 'nested' | 'flat';
+    }>;
+}): Record<string, {
+    structure: 'nested' | 'flat';
+}>;
+/**
+ * Get list of asset types to sync from configuration
+ * @param config - ClaudeConfig from package.json
+ * @returns Array of asset type names
+ */
+export declare function getAssetTypes(config: {
+    assetPath: string;
+    assets?: Record<string, {
+        structure: 'nested' | 'flat';
+    }>;
+}): string[];

package/dist/utils/package.mjs

@@ -1,10 +1,8 @@
 import { execSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { FS_PATTERNS, DEFAULT_ASSET_TYPES } from '../core/constants.mjs';
 
-const GITHUB_HTTPS_URL_PATTERN = /https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/;
-const GITHUB_SSH_URL_PATTERN = /git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/;
-const GITHUB_SHORTHAND_PATTERN = /^github:([^/]+)\/([^/]+)$/;
 const readPackageJson = (packageName, cwd = process.cwd()) => {
     try {
         const packageJsonPath = join(cwd, 'node_modules', packageName, 'package.json');
@@ -27,21 +25,21 @@ const parseGitHubRepo = (repository) => {
     if (!repository || typeof repository.url !== 'string')
         return null;
     const url = repository.url;
-    const httpsMatch = url.match(GITHUB_HTTPS_URL_PATTERN);
+    const httpsMatch = url.match(FS_PATTERNS.GITHUB_HTTPS_URL);
     if (httpsMatch)
         return {
             owner: httpsMatch[1],
             repo: httpsMatch[2],
             directory: repository.directory,
         };
-    const sshMatch = url.match(GITHUB_SSH_URL_PATTERN);
+    const sshMatch = url.match(FS_PATTERNS.GITHUB_SSH_URL);
     if (sshMatch)
         return {
             owner: sshMatch[1],
             repo: sshMatch[2],
             directory: repository.directory,
         };
-    const shorthandMatch = url.match(GITHUB_SHORTHAND_PATTERN);
+    const shorthandMatch = url.match(FS_PATTERNS.GITHUB_SHORTHAND);
     if (shorthandMatch)
         return {
             owner: shorthandMatch[1],
@@ -129,5 +127,11 @@ const readLocalPackageJson = (packageName, cwd = process.cwd()) => {
         return null;
     }
 };
+function getAssetTypes(config) {
+    if (!config.assets) {
+        return Array.from(DEFAULT_ASSET_TYPES);
+    }
+    return Object.keys(config.assets);
+}
 
-export { buildAssetPath, buildVersionTag, findGitRoot, findWorkspaceLocation, findWorkspaceRoot, getWorkspaceList, parseGitHubRepo, readLocalPackageJson, readPackageJson };
+export { buildAssetPath, buildVersionTag, findGitRoot, findWorkspaceLocation, findWorkspaceRoot, getAssetTypes, getWorkspaceList, parseGitHubRepo, readLocalPackageJson, readPackageJson };

package/dist/utils/packageName.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function parsePackageName(packageName) {
+    if (packageName.startsWith('@')) {
+        const [scope, name] = packageName.split('/');
+        return [scope, name];
+    }
+    return ['', packageName];
+}
+function kebabToCamel(str) {
+    return str.replace(/-./g, (match) => match[1].toUpperCase());
+}
+function packageNameToPrefix(packageName) {
+    const [scope, name] = parsePackageName(packageName);
+    if (!scope) {
+        return kebabToCamel(name);
+    }
+    const scopeWithoutAt = scope.replace('@', '');
+    const camelName = kebabToCamel(name);
+    return `${scopeWithoutAt}-${camelName}`;
+}
+
+exports.packageNameToPrefix = packageNameToPrefix;
+exports.parsePackageName = parsePackageName;

package/dist/utils/packageName.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parse scoped package name into scope and name
+ * @param packageName - Package name (e.g., "@canard/schema-form")
+ * @returns [scope, name] tuple (e.g., ["@canard", "schema-form"])
+ *
+ * @example
+ * parsePackageName('@canard/schema-form') // ['@canard', 'schema-form']
+ * parsePackageName('lodash') // ['', 'lodash']
+ */
+export declare function parsePackageName(packageName: string): [string, string];
+/**
+ * Converts a scoped package name to a flat prefix
+ * @param packageName - Scoped package name (e.g., '@canard/schema-form')
+ * @returns Flat prefix (e.g., 'canard-schemaForm')
+ *
+ * @example
+ * packageNameToPrefix('@canard/schema-form') // 'canard-schemaForm'
+ * packageNameToPrefix('@winglet/react-utils') // 'winglet-reactUtils'
+ * packageNameToPrefix('lodash') // 'lodash'
+ */
+export declare function packageNameToPrefix(packageName: string): string;
+/**
+ * Converts a flat prefix back to package name
+ * @param prefix - Flat prefix (e.g., 'canard-schemaForm')
+ * @returns Package name (e.g., '@canard/schema-form')
+ *
+ * @example
+ * prefixToPackageName('canard-schemaForm') // '@canard/schema-form'
+ * prefixToPackageName('winglet-reactUtils') // '@winglet/react-utils'
+ * prefixToPackageName('lodash') // 'lodash'
+ */
+export declare function prefixToPackageName(prefix: string): string;

package/dist/utils/packageName.mjs

@@ -0,0 +1,21 @@
+function parsePackageName(packageName) {
+    if (packageName.startsWith('@')) {
+        const [scope, name] = packageName.split('/');
+        return [scope, name];
+    }
+    return ['', packageName];
+}
+function kebabToCamel(str) {
+    return str.replace(/-./g, (match) => match[1].toUpperCase());
+}
+function packageNameToPrefix(packageName) {
+    const [scope, name] = parsePackageName(packageName);
+    if (!scope) {
+        return kebabToCamel(name);
+    }
+    const scopeWithoutAt = scope.replace('@', '');
+    const camelName = kebabToCamel(name);
+    return `${scopeWithoutAt}-${camelName}`;
+}
+
+export { packageNameToPrefix, parsePackageName };

package/dist/utils/paths.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var path = require('node:path');
+var constants = require('../core/constants.cjs');
+var packageName = require('./packageName.cjs');
+
+function getDestinationDir(cwd, packageName$1, assetType) {
+    const [scope, name] = packageName.parsePackageName(packageName$1);
+    if (scope)
+        return path.join(cwd, constants.CLAUDE_BASE_DIR, assetType, scope, name);
+    return path.join(cwd, constants.CLAUDE_BASE_DIR, assetType, name);
+}
+function getFlatDestinationDir(cwd, assetType) {
+    return path.join(cwd, constants.CLAUDE_BASE_DIR, assetType);
+}
+
+exports.getDestinationDir = getDestinationDir;
+exports.getFlatDestinationDir = getFlatDestinationDir;

package/dist/utils/paths.d.ts

@@ -0,0 +1,55 @@
+import type { AssetType } from './types';
+/**
+ * Get the destination directory for synced assets (nested structure)
+ * @param cwd - Current working directory
+ * @param packageName - Package name
+ * @param assetType - Asset type (commands or skills)
+ * @returns Full path to destination directory
+ *
+ * @example
+ * getDestinationDir('/project', '@canard/schema-form', 'commands')
+ * // => '/project/.claude/commands/@canard/schema-form'
+ */
+export declare function getDestinationDir(cwd: string, packageName: string, assetType: AssetType): string;
+/**
+ * Get the flat destination directory for synced assets (no nesting)
+ * @param cwd - Current working directory
+ * @param assetType - Asset type (commands or skills)
+ * @returns Full path to flat destination directory
+ *
+ * @example
+ * getFlatDestinationDir('/project', 'commands')
+ * // => '/project/.claude/commands'
+ */
+export declare function getFlatDestinationDir(cwd: string, assetType: AssetType): string;
+/**
+ * Get the path to sync metadata file for nested structure
+ * @param cwd - Current working directory
+ * @param packageName - Package name
+ * @param assetType - Asset type
+ * @returns Full path to .sync-meta.json
+ */
+export declare function getMetaFilePath(cwd: string, packageName: string, assetType: AssetType): string;
+/**
+ * Get the path to unified sync metadata file
+ * @param cwd - Current working directory
+ * @returns Full path to .claude/.sync-meta.json
+ */
+export declare function getUnifiedMetaFilePath(cwd: string): string;
+/**
+ * Get the path to an asset file in nested structure
+ * @param cwd - Current working directory
+ * @param packageName - Package name
+ * @param assetType - Asset type
+ * @param fileName - File name
+ * @returns Full path to asset file
+ */
+export declare function getAssetFilePath(cwd: string, packageName: string, assetType: AssetType, fileName: string): string;
+/**
+ * Get the path to an asset file in flat structure
+ * @param cwd - Current working directory
+ * @param assetType - Asset type
+ * @param flatFileName - Flat file name with prefix
+ * @returns Full path to flat asset file
+ */
+export declare function getFlatAssetFilePath(cwd: string, assetType: AssetType, flatFileName: string): string;

package/dist/utils/paths.mjs

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { CLAUDE_BASE_DIR } from '../core/constants.mjs';
+import { parsePackageName } from './packageName.mjs';
+
+function getDestinationDir(cwd, packageName, assetType) {
+    const [scope, name] = parsePackageName(packageName);
+    if (scope)
+        return join(cwd, CLAUDE_BASE_DIR, assetType, scope, name);
+    return join(cwd, CLAUDE_BASE_DIR, assetType, name);
+}
+function getFlatDestinationDir(cwd, assetType) {
+    return join(cwd, CLAUDE_BASE_DIR, assetType);
+}
+
+export { getDestinationDir, getFlatDestinationDir };

package/dist/utils/types.d.ts

@@ -1,9 +1,27 @@
+/**
+ * Asset structure type (nested or flat)
+ */
+export type AssetStructure = 'nested' | 'flat';
+/**
+ * Configuration for a specific asset type
+ */
+export interface AssetTypeConfig {
+    structure: AssetStructure;
+}
+/**
+ * Configuration mapping asset types to their structure
+ */
+export interface AssetsConfig {
+    [assetType: string]: AssetTypeConfig;
+}
 /**
  * Claude configuration in package.json
  */
 export interface ClaudeConfig {
     /** Path to Claude assets directory (e.g., "docs/claude") */
     assetPath: string;
+    /** Optional configuration for asset types */
+    assets?: AssetsConfig;
 }
 /**
  * Repository information from package.json
@@ -52,9 +70,9 @@ export interface SyncMeta {
     files: string[];
 }
 /**
- * Asset type (commands or skills)
+ * Asset type (can be any string, not limited to commands/skills/agents)
  */
-export type AssetType = 'commands' | 'skills';
+export type AssetType = string;
 /**
  * Sync result for a single package
  */
@@ -63,10 +81,7 @@ export interface SyncResult {
     success: boolean;
     skipped: boolean;
     reason?: string;
-    syncedFiles?: {
-        commands: string[];
-        skills: string[];
-    };
+    syncedFiles?: Record<string, string[]>;
 }
 /**
  * CLI options
@@ -78,6 +93,8 @@ export interface CliOptions {
     local: boolean;
     /** Custom git ref (branch, tag, or commit) to fetch from */
     ref?: string;
+    /** Use flat structure (default: true in v2) */
+    flat?: boolean;
 }
 /**
  * Workspace info from yarn workspaces
@@ -86,3 +103,133 @@ export interface WorkspaceInfo {
     name: string;
     location: string;
 }
+/**
+ * Unified sync metadata for all packages (flat structure)
+ */
+export interface UnifiedSyncMeta {
+    /** Schema version for migration support */
+    schemaVersion: string;
+    /** Last sync timestamp */
+    syncedAt: string;
+    /** Package metadata keyed by transformed name (e.g., "canard-schemaForm") */
+    packages: Record<string, PackageSyncInfo>;
+}
+/**
+ * Individual package sync info within unified meta
+ */
+export interface PackageSyncInfo {
+    /** Original package name (e.g., "@canard/schema-form") */
+    originalName: string;
+    /** Package version at sync time */
+    version: string;
+    /** Whether this package is from local workspace (true) or remote npm (false/undefined) */
+    local?: boolean;
+    /** Synced files - dynamic structure based on asset configuration:
+     * - For nested structure: array of original filenames
+     * - For flat structure: array of FileMapping with original → transformed
+     */
+    files: Record<string, string[] | FileMapping[]>;
+    /** Optional exclusions for selective syncing */
+    exclusions?: {
+        /** Excluded directory paths (e.g., ["skills/deprecated"]) */
+        directories: string[];
+        /** Excluded file paths (e.g., ["commands/old-cmd.md"]) */
+        files: string[];
+    };
+}
+/**
+ * File name mapping (original to transformed)
+ */
+export interface FileMapping {
+    /** Original file name (e.g., "guide.md") */
+    original: string;
+    /** Transformed file name (e.g., "canard-schemaForm_guide.md") */
+    transformed: string;
+}
+/**
+ * Add command selection result
+ */
+export interface AddCommandSelection {
+    /** Package name */
+    packageName: string;
+    /** Source type */
+    source: 'local' | 'npm';
+    /** Git ref (branch, tag, or commit) */
+    ref?: string;
+    /** Included assets by type */
+    includedAssets: Record<string, string[]>;
+    /** Excluded assets by type */
+    excludedAssets: Record<string, string[]>;
+}
+/**
+ * Tree node for asset selection
+ */
+export interface TreeNode {
+    /** Unique identifier */
+    id: string;
+    /** Node label */
+    label: string;
+    /** Full path */
+    path: string;
+    /** Node type */
+    type: 'directory' | 'file' | 'skill-directory';
+    /** Child nodes */
+    children?: TreeNode[];
+    /** Selection state */
+    selected: boolean;
+    /** Expanded state */
+    expanded: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Additional metadata */
+    metadata?: {
+        assetType: string;
+        originalName?: string;
+        transformedName?: string;
+    };
+}
+/**
+ * Re-export asset structure utilities from core module
+ *
+ * @deprecated These exports are kept for backward compatibility only.
+ * Please update your imports to use the recommended paths below.
+ *
+ * Migration Guide:
+ * ================
+ *
+ * ❌ OLD (Deprecated - will be removed in v1.0.0)
+ * ```typescript
+ * import {
+ *   DEFAULT_ASSET_TYPES,
+ *   DEFAULT_ASSET_STRUCTURES,
+ *   getAssetStructure,
+ *   detectStructureType,
+ *   validateAssetStructure,
+ *   normalizeAssetStructure,
+ * } from './utils/types';
+ * ```
+ *
+ * ✅ NEW (Recommended)
+ * ```typescript
+ * import {
+ *   DEFAULT_ASSET_TYPES,
+ *   DEFAULT_ASSET_STRUCTURES,
+ *   getAssetStructure,
+ *   detectStructureType,
+ *   validateAssetStructure,
+ *   normalizeAssetStructure,
+ * } from './core/assetStructure';
+ * ```
+ *
+ * Why the change?
+ * - Clearer module organization (asset structure logic lives in core/)
+ * - Direct imports are more maintainable and tree-shake friendly
+ * - Reduces coupling between utils and core modules
+ *
+ * Timeline:
+ * - v0.x: Old imports work (with deprecation warnings)
+ * - v1.0.0: Re-exports removed
+ *
+ * @see ../core/assetStructure for the actual implementations
+ */
+export { DEFAULT_ASSET_TYPES, DEFAULT_ASSET_STRUCTURES, getAssetStructure, detectStructureType, validateAssetStructure, normalizeAssetStructure, } from '../core/assetStructure';

package/dist/utils/version.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function compareVersions(v1, v2) {
+    return v1 === v2;
+}
+function needsVersionSync(currentVersion, syncedVersion) {
+    if (syncedVersion === undefined) {
+        return true;
+    }
+    if (currentVersion === '' || syncedVersion === '') {
+        return true;
+    }
+    return !compareVersions(currentVersion, syncedVersion);
+}
+
+exports.compareVersions = compareVersions;
+exports.needsVersionSync = needsVersionSync;