@slats/claude-assets-sync 0.0.1 → 0.0.3

package/dist/core/sync.cjs

@@ -1,11 +1,15 @@
 'use strict';
 
 var logger = require('../utils/logger.cjs');
+var nameTransform = require('../utils/nameTransform.cjs');
 var _package = require('../utils/package.cjs');
+var paths = require('../utils/paths.cjs');
 var filesystem = require('./filesystem.cjs');
 var github = require('./github.cjs');
+var syncMeta = require('./syncMeta.cjs');
+var assetStructure = require('./assetStructure.cjs');
 
-const syncPackage = async (packageName, options, cwd = process.cwd(), outputDir) => {
+const syncPackage = async (packageName, options, cwd = process.cwd(), exclusions, outputDir) => {
     logger.logger.packageStart(packageName);
     try {
         const destDir = outputDir ?? _package.findGitRoot(cwd) ?? cwd;
@@ -37,78 +41,257 @@ const syncPackage = async (packageName, options, cwd = process.cwd(), outputDir)
                 reason: 'Unable to parse GitHub repository URL',
             };
         }
-        if (!options.force &&
-            !filesystem.needsSync(destDir, packageName, packageInfo.version)) {
+        const useFlat = options.flat !== false;
+        if (useFlat) {
+            const prefix = nameTransform.packageNameToPrefix(packageName);
+            const unifiedMeta = syncMeta.readUnifiedSyncMeta(destDir) ?? syncMeta.createEmptyUnifiedMeta();
+            if (!options.force &&
+                !syncMeta.needsSyncUnified(unifiedMeta, prefix, packageInfo.version)) {
+                return {
+                    packageName,
+                    success: true,
+                    skipped: true,
+                    reason: `Already synced at version ${packageInfo.version}`,
+                };
+            }
+            const tag = options.ref ?? _package.buildVersionTag(packageName, packageInfo.version);
+            const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
+            logger.logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
+            const assetTypes = _package.getAssetTypes(packageInfo.claude);
+            const assetFiles = await github.fetchAssetFiles(repoInfo, assetPath, tag, assetTypes);
+            let totalFiles = 0;
+            for (const assetType of assetTypes) {
+                totalFiles += (assetFiles[assetType] || []).length;
+            }
+            if (totalFiles === 0)
+                return {
+                    packageName,
+                    success: false,
+                    skipped: true,
+                    reason: `No assets found in package (checked: ${assetTypes.join(', ')})`,
+                };
+            const foundSummary = assetTypes
+                .map((type) => `${(assetFiles[type] || []).length} ${type}`)
+                .join(', ');
+            logger.logger.step('Found', foundSummary);
+            const fileMappings = {};
+            for (const assetType of assetTypes) {
+                const entries = assetFiles[assetType] || [];
+                if (entries.length === 0)
+                    continue;
+                const filteredEntries = entries.filter((entry) => {
+                    if (!exclusions)
+                        return true;
+                    const excludedPath = `${assetType}/${entry.name}`;
+                    return !exclusions.files.includes(excludedPath);
+                });
+                if (filteredEntries.length === 0)
+                    continue;
+                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                if (structure === 'nested') {
+                    fileMappings[assetType] = filteredEntries.map((e) => e.name);
+                }
+                else {
+                    fileMappings[assetType] = filteredEntries.map((entry) => ({
+                        original: entry.name,
+                        transformed: nameTransform.toFlatFileName(prefix, entry.name),
+                    }));
+                }
+            }
+            if (options.dryRun) {
+                for (const assetType of assetTypes) {
+                    const mappings = fileMappings[assetType];
+                    if (!mappings || mappings.length === 0)
+                        continue;
+                    const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                    if (structure === 'nested') {
+                        logger.logger.step(`Would sync ${assetType} to`, paths.getDestinationDir(destDir, packageName, assetType));
+                        mappings.forEach((fileName) => {
+                            logger.logger.file('create', fileName);
+                        });
+                    }
+                    else {
+                        logger.logger.step(`Would sync ${assetType} to`, paths.getFlatDestinationDir(destDir, assetType));
+                        mappings.forEach((mapping) => {
+                            logger.logger.file('create', mapping.transformed);
+                        });
+                    }
+                }
+                const syncedFiles = {};
+                for (const assetType of assetTypes) {
+                    const mappings = fileMappings[assetType];
+                    if (!mappings || mappings.length === 0)
+                        continue;
+                    if (typeof mappings[0] === 'string') {
+                        syncedFiles[assetType] = mappings;
+                    }
+                    else {
+                        syncedFiles[assetType] = mappings.map((m) => m.transformed);
+                    }
+                }
+                return {
+                    packageName,
+                    success: true,
+                    skipped: false,
+                    syncedFiles,
+                };
+            }
+            for (const assetType of assetTypes) {
+                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                if (structure === 'nested') {
+                    filesystem.cleanAssetDir(destDir, packageName, assetType);
+                }
+                else {
+                    filesystem.cleanFlatAssetFiles(destDir, assetType, prefix, unifiedMeta);
+                }
+            }
+            for (const assetType of assetTypes) {
+                const entries = assetFiles[assetType] || [];
+                if (entries.length === 0)
+                    continue;
+                const filteredEntries = entries.filter((entry) => {
+                    if (!exclusions)
+                        return true;
+                    const excludedPath = `${assetType}/${entry.name}`;
+                    return !exclusions.files.includes(excludedPath);
+                });
+                if (filteredEntries.length === 0)
+                    continue;
+                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                logger.logger.step('Downloading', assetType);
+                const downloadedFiles = await github.downloadAssetFiles(repoInfo, assetPath, assetType, filteredEntries, tag);
+                if (structure === 'nested') {
+                    for (const [fileName, content] of downloadedFiles) {
+                        filesystem.writeAssetFile(destDir, packageName, assetType, fileName, content);
+                        logger.logger.file('create', fileName);
+                    }
+                }
+                else {
+                    const mappings = fileMappings[assetType];
+                    for (const [fileName, content] of downloadedFiles) {
+                        const mapping = mappings.find((m) => m.original === fileName);
+                        const flatName = mapping?.transformed ?? nameTransform.toFlatFileName(prefix, fileName);
+                        filesystem.writeFlatAssetFile(destDir, assetType, flatName, content);
+                        logger.logger.file('create', flatName);
+                    }
+                }
+            }
+            const updatedMeta = syncMeta.updatePackageInMeta(unifiedMeta, prefix, {
+                originalName: packageName,
+                version: packageInfo.version,
+                local: options.local,
+                files: fileMappings,
+                exclusions: exclusions &&
+                    (exclusions.directories.length > 0 || exclusions.files.length > 0)
+                    ? exclusions
+                    : undefined,
+            });
+            syncMeta.writeUnifiedSyncMeta(destDir, updatedMeta);
+            const syncedFiles = {};
+            for (const assetType of assetTypes) {
+                const mappings = fileMappings[assetType];
+                if (!mappings || mappings.length === 0)
+                    continue;
+                if (typeof mappings[0] === 'string') {
+                    syncedFiles[assetType] = mappings;
+                }
+                else {
+                    syncedFiles[assetType] = mappings.map((m) => m.transformed);
+                }
+            }
             return {
                 packageName,
                 success: true,
-                skipped: true,
-                reason: `Already synced at version ${packageInfo.version}`,
+                skipped: false,
+                syncedFiles,
             };
         }
-        const tag = options.ref ?? _package.buildVersionTag(packageName, packageInfo.version);
-        const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
-        logger.logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
-        const { commands, skills } = await github.fetchAssetFiles(repoInfo, assetPath, tag);
-        if (commands.length === 0 && skills.length === 0)
-            return {
-                packageName,
-                success: false,
-                skipped: true,
-                reason: 'No commands or skills found in package',
-            };
-        logger.logger.step('Found', `${commands.length} commands, ${skills.length} skills`);
-        if (options.dryRun) {
-            if (commands.length > 0) {
-                logger.logger.step('Would sync commands to', filesystem.getDestinationDir(destDir, packageName, 'commands'));
-                commands.forEach((entry) => logger.logger.file('create', entry.name));
+        else {
+            const tag = options.ref ?? _package.buildVersionTag(packageName, packageInfo.version);
+            const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
+            logger.logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
+            const assetTypes = _package.getAssetTypes(packageInfo.claude);
+            const assetFiles = await github.fetchAssetFiles(repoInfo, assetPath, tag, assetTypes);
+            let totalFiles = 0;
+            for (const assetType of assetTypes) {
+                totalFiles += (assetFiles[assetType] || []).length;
+            }
+            if (totalFiles === 0)
+                return {
+                    packageName,
+                    success: false,
+                    skipped: true,
+                    reason: `No assets found in package (checked: ${assetTypes.join(', ')})`,
+                };
+            const foundSummary = assetTypes
+                .map((type) => `${(assetFiles[type] || []).length} ${type}`)
+                .join(', ');
+            logger.logger.step('Found', foundSummary);
+            if (!options.force &&
+                !filesystem.needsSync(destDir, packageName, packageInfo.version, assetTypes)) {
+                return {
+                    packageName,
+                    success: true,
+                    skipped: true,
+                    reason: `Already synced at version ${packageInfo.version}`,
+                };
+            }
+            if (options.dryRun) {
+                const syncedFiles = {};
+                for (const assetType of assetTypes) {
+                    const entries = assetFiles[assetType] || [];
+                    if (entries.length === 0)
+                        continue;
+                    const filteredEntries = entries.filter((entry) => {
+                        if (!exclusions)
+                            return true;
+                        const excludedPath = `${assetType}/${entry.name}`;
+                        return !exclusions.files.includes(excludedPath);
+                    });
+                    if (filteredEntries.length === 0)
+                        continue;
+                    logger.logger.step(`Would sync ${assetType} to`, paths.getDestinationDir(destDir, packageName, assetType));
+                    filteredEntries.forEach((entry) => logger.logger.file('create', entry.name));
+                    syncedFiles[assetType] = filteredEntries.map((e) => e.name);
+                }
+                return {
+                    packageName,
+                    success: true,
+                    skipped: false,
+                    syncedFiles,
+                };
             }
-            if (skills.length > 0) {
-                logger.logger.step('Would sync skills to', filesystem.getDestinationDir(destDir, packageName, 'skills'));
-                skills.forEach((entry) => logger.logger.file('create', entry.name));
+            const syncedFiles = {};
+            for (const assetType of assetTypes) {
+                const entries = assetFiles[assetType] || [];
+                if (entries.length === 0)
+                    continue;
+                const filteredEntries = entries.filter((entry) => {
+                    if (!exclusions)
+                        return true;
+                    const excludedPath = `${assetType}/${entry.name}`;
+                    return !exclusions.files.includes(excludedPath);
+                });
+                if (filteredEntries.length === 0)
+                    continue;
+                logger.logger.step('Downloading', assetType);
+                const downloadedFiles = await github.downloadAssetFiles(repoInfo, assetPath, assetType, filteredEntries, tag);
+                filesystem.cleanAssetDir(destDir, packageName, assetType);
+                syncedFiles[assetType] = [];
+                for (const [fileName, content] of downloadedFiles) {
+                    filesystem.writeAssetFile(destDir, packageName, assetType, fileName, content);
+                    logger.logger.file('create', fileName);
+                    syncedFiles[assetType].push(fileName);
+                }
+                filesystem.writeSyncMeta(destDir, packageName, assetType, filesystem.createSyncMeta(packageInfo.version, syncedFiles[assetType]));
             }
             return {
                 packageName,
                 success: true,
                 skipped: false,
-                syncedFiles: {
-                    commands: commands.map((e) => e.name),
-                    skills: skills.map((e) => e.name),
-                },
+                syncedFiles,
             };
         }
-        const syncedFiles = {
-            commands: [],
-            skills: [],
-        };
-        if (commands.length > 0) {
-            logger.logger.step('Downloading', 'commands');
-            const commandFiles = await github.downloadAssetFiles(repoInfo, assetPath, 'commands', commands, tag);
-            filesystem.cleanAssetDir(destDir, packageName, 'commands');
-            for (const [fileName, content] of commandFiles) {
-                filesystem.writeAssetFile(destDir, packageName, 'commands', fileName, content);
-                logger.logger.file('create', fileName);
-                syncedFiles.commands.push(fileName);
-            }
-            filesystem.writeSyncMeta(destDir, packageName, 'commands', filesystem.createSyncMeta(packageInfo.version, syncedFiles.commands));
-        }
-        if (skills.length > 0) {
-            logger.logger.step('Downloading', 'skills');
-            const skillFiles = await github.downloadAssetFiles(repoInfo, assetPath, 'skills', skills, tag);
-            filesystem.cleanAssetDir(destDir, packageName, 'skills');
-            for (const [fileName, content] of skillFiles) {
-                filesystem.writeAssetFile(destDir, packageName, 'skills', fileName, content);
-                logger.logger.file('create', fileName);
-                syncedFiles.skills.push(fileName);
-            }
-            filesystem.writeSyncMeta(destDir, packageName, 'skills', filesystem.createSyncMeta(packageInfo.version, syncedFiles.skills));
-        }
-        return {
-            packageName,
-            success: true,
-            skipped: false,
-            syncedFiles,
-        };
     }
     catch (error) {
         if (error instanceof github.RateLimitError)
@@ -133,7 +316,7 @@ const syncPackages = async (packages, options, cwd = process.cwd()) => {
     if (gitRoot)
         logger.logger.info(`[Output] ${gitRoot}/.claude\n`);
     for (const packageName of packages) {
-        const result = await syncPackage(packageName, options, cwd, gitRoot ?? undefined);
+        const result = await syncPackage(packageName, options, cwd, undefined, gitRoot ?? undefined);
         logger.logger.packageEnd(packageName, result);
         results.push(result);
     }

package/dist/core/sync.d.ts

@@ -4,9 +4,13 @@ import type { CliOptions, SyncResult } from '../utils/types';
  * @param packageName - Package name to sync
  * @param options - CLI options
  * @param cwd - Current working directory
+ * @param exclusions - Optional exclusions for selective syncing
  * @returns Sync result
  */
-export declare const syncPackage: (packageName: string, options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref">, cwd?: string, outputDir?: string) => Promise<SyncResult>;
+export declare const syncPackage: (packageName: string, options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref" | "flat">, cwd?: string, exclusions?: {
+    directories: string[];
+    files: string[];
+}, outputDir?: string) => Promise<SyncResult>;
 /**
  * Sync Claude assets for multiple packages
  * @param packages - List of package names to sync
@@ -14,4 +18,4 @@ export declare const syncPackage: (packageName: string, options: Pick<CliOptions
  * @param cwd - Current working directory
  * @returns Array of sync results
  */
-export declare const syncPackages: (packages: string[], options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref">, cwd?: string) => Promise<SyncResult[]>;
+export declare const syncPackages: (packages: string[], options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref" | "flat">, cwd?: string) => Promise<SyncResult[]>;