@slats/claude-assets-sync 0.1.3 → 0.2.0

package/dist/core/sync.mjs

@@ -1,397 +0,0 @@
-import { logger } from '../utils/logger.mjs';
-import { toFlatFileName } from '../utils/nameTransform.mjs';
-import { findGitRoot, readLocalPackageJson, readPackageJson, resolveClaudeConfig, parseGitHubRepo, buildAssetPath, getAssetTypes, buildVersionTag } from '../utils/package.mjs';
-import { packageNameToPrefix } from '../utils/packageName.mjs';
-import { getDestinationDir, getFlatDestinationDir } from '../utils/paths.mjs';
-import { SCHEMA_VERSIONS } from './constants.mjs';
-import { cleanAssetDir, cleanFlatAssetFiles, writeAssetFile, writeFlatAssetFile, needsSync, writeSyncMeta, createSyncMeta } from './filesystem.mjs';
-import { fetchAssetFiles, downloadAssetFiles, RateLimitError } from './github.mjs';
-import { canUseLocalSource, fetchLocalAssetFiles, downloadLocalAssetFiles } from './localSource.mjs';
-import { readUnifiedSyncMeta, createEmptyUnifiedMeta, needsSyncUnified, updatePackageInMeta, writeUnifiedSyncMeta } from './syncMeta.mjs';
-import { getAssetStructure } from './assetStructure.mjs';
-
-function groupEntriesIntoSkillUnits(entries, prefix) {
-    const dirGroups = new Map();
-    const singleFiles = [];
-    for (const entry of entries) {
-        const slashIndex = entry.name.indexOf('/');
-        if (slashIndex === -1) {
-            singleFiles.push({
-                name: entry.name,
-                isDirectory: false,
-                transformed: toFlatFileName(prefix, entry.name),
-            });
-        }
-        else {
-            const dirName = entry.name.substring(0, slashIndex);
-            const internalFile = entry.name.substring(slashIndex + 1);
-            if (!dirGroups.has(dirName)) {
-                dirGroups.set(dirName, []);
-            }
-            dirGroups.get(dirName).push(internalFile);
-        }
-    }
-    const dirSkillUnits = [];
-    for (const [dirName, internalFiles] of dirGroups.entries()) {
-        dirSkillUnits.push({
-            name: dirName,
-            isDirectory: true,
-            transformed: toFlatFileName(prefix, dirName),
-            internalFiles,
-        });
-    }
-    return [...singleFiles, ...dirSkillUnits];
-}
-const syncPackage = async (packageName, options, cwd = process.cwd(), exclusions, outputDir) => {
-    logger.packageStart(packageName);
-    try {
-        const destDir = outputDir ?? findGitRoot(cwd) ?? cwd;
-        const packageInfo = options.local
-            ? readLocalPackageJson(packageName, cwd)
-            : readPackageJson(packageName, cwd);
-        if (!packageInfo) {
-            const location = options.local ? 'workspace' : 'node_modules';
-            return {
-                packageName,
-                success: false,
-                skipped: true,
-                reason: `Package not found in ${location}`,
-            };
-        }
-        const claudeConfig = resolveClaudeConfig(packageInfo.claude);
-        const repoInfo = parseGitHubRepo(packageInfo.repository);
-        const useFlat = options.flat !== false;
-        if (useFlat) {
-            const prefix = packageNameToPrefix(packageName);
-            const unifiedMeta = readUnifiedSyncMeta(destDir) ?? createEmptyUnifiedMeta();
-            if (!options.force &&
-                !needsSyncUnified(unifiedMeta, prefix, packageInfo.version)) {
-                return {
-                    packageName,
-                    success: true,
-                    skipped: true,
-                    reason: `Already synced at version ${packageInfo.version}`,
-                };
-            }
-            const assetPath = buildAssetPath(claudeConfig.assetPath);
-            const useLocalSource = options.ref
-                ? { available: false }
-                : canUseLocalSource(packageName, packageInfo.version, assetPath, cwd);
-            const assetTypes = getAssetTypes(claudeConfig);
-            let assetFiles;
-            let isLocalSource;
-            if (useLocalSource.available && useLocalSource.docsPath) {
-                isLocalSource = true;
-                logger.step('Using', 'local docs from node_modules');
-                assetFiles = await fetchLocalAssetFiles(useLocalSource.docsPath, assetTypes);
-            }
-            else {
-                if (!repoInfo) {
-                    return {
-                        packageName,
-                        success: false,
-                        skipped: true,
-                        reason: `Package ${packageName} has no valid GitHub repository URL for remote fetch`,
-                    };
-                }
-                isLocalSource = false;
-                const tag = options.ref ?? buildVersionTag(packageName, packageInfo.version);
-                logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
-                assetFiles = await 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.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 = getAssetStructure(assetType, claudeConfig);
-                if (structure === 'nested') {
-                    fileMappings[assetType] = filteredEntries.map((e) => ({
-                        name: e.name,
-                        isDirectory: false,
-                    }));
-                }
-                else {
-                    fileMappings[assetType] = groupEntriesIntoSkillUnits(filteredEntries, prefix);
-                }
-            }
-            if (options.dryRun) {
-                for (const assetType of assetTypes) {
-                    const units = fileMappings[assetType];
-                    if (!units || units.length === 0)
-                        continue;
-                    const structure = getAssetStructure(assetType, claudeConfig);
-                    if (structure === 'nested') {
-                        logger.step(`Would sync ${assetType} to`, getDestinationDir(destDir, packageName, assetType));
-                        units.forEach((unit) => {
-                            logger.file('create', unit.name);
-                        });
-                    }
-                    else {
-                        logger.step(`Would sync ${assetType} to`, getFlatDestinationDir(destDir, assetType));
-                        units.forEach((unit) => {
-                            const displayName = unit.transformed ?? unit.name;
-                            logger.file('create', displayName);
-                        });
-                    }
-                }
-                const syncedFiles = {};
-                for (const assetType of assetTypes) {
-                    const units = fileMappings[assetType];
-                    if (!units || units.length === 0)
-                        continue;
-                    syncedFiles[assetType] = units.map((u) => u.transformed ?? u.name);
-                }
-                return {
-                    packageName,
-                    success: true,
-                    skipped: false,
-                    syncedFiles,
-                };
-            }
-            for (const assetType of assetTypes) {
-                const structure = getAssetStructure(assetType, claudeConfig);
-                if (structure === 'nested') {
-                    cleanAssetDir(destDir, packageName, assetType);
-                }
-                else {
-                    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 = getAssetStructure(assetType, claudeConfig);
-                logger.step('Downloading', assetType);
-                let downloadedFiles;
-                if (isLocalSource && useLocalSource.docsPath) {
-                    downloadedFiles = await downloadLocalAssetFiles(useLocalSource.docsPath, assetType, filteredEntries);
-                }
-                else {
-                    const tag = options.ref ?? buildVersionTag(packageName, packageInfo.version);
-                    downloadedFiles = await downloadAssetFiles(repoInfo, assetPath, assetType, filteredEntries, tag);
-                }
-                if (structure === 'nested') {
-                    for (const [fileName, content] of downloadedFiles) {
-                        writeAssetFile(destDir, packageName, assetType, fileName, content);
-                        logger.file('create', fileName);
-                    }
-                }
-                else {
-                    for (const [fileName, content] of downloadedFiles) {
-                        const flatName = toFlatFileName(prefix, fileName);
-                        writeFlatAssetFile(destDir, assetType, flatName, content);
-                        logger.file('create', flatName);
-                    }
-                }
-            }
-            const updatedMeta = 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,
-            });
-            updatedMeta.skillUnitFormat = SCHEMA_VERSIONS.SKILL_UNIT_FORMAT;
-            writeUnifiedSyncMeta(destDir, updatedMeta);
-            const syncedFiles = {};
-            for (const assetType of assetTypes) {
-                const units = fileMappings[assetType];
-                if (!units || units.length === 0)
-                    continue;
-                syncedFiles[assetType] = units.map((u) => u.transformed ?? u.name);
-            }
-            return {
-                packageName,
-                success: true,
-                skipped: false,
-                syncedFiles,
-            };
-        }
-        else {
-            const assetPath = buildAssetPath(claudeConfig.assetPath);
-            const useLocalSource = options.ref
-                ? { available: false }
-                : canUseLocalSource(packageName, packageInfo.version, assetPath, cwd);
-            const assetTypes = getAssetTypes(claudeConfig);
-            let assetFiles;
-            let isLocalSource;
-            if (useLocalSource.available && useLocalSource.docsPath) {
-                isLocalSource = true;
-                logger.step('Using', 'local docs from node_modules');
-                assetFiles = await fetchLocalAssetFiles(useLocalSource.docsPath, assetTypes);
-            }
-            else {
-                if (!repoInfo) {
-                    return {
-                        packageName,
-                        success: false,
-                        skipped: true,
-                        reason: `Package ${packageName} has no valid GitHub repository URL for remote fetch`,
-                    };
-                }
-                isLocalSource = false;
-                const tag = options.ref ?? buildVersionTag(packageName, packageInfo.version);
-                logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
-                assetFiles = await 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.step('Found', foundSummary);
-            if (!options.force &&
-                !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.step(`Would sync ${assetType} to`, getDestinationDir(destDir, packageName, assetType));
-                    filteredEntries.forEach((entry) => logger.file('create', entry.name));
-                    syncedFiles[assetType] = filteredEntries.map((e) => e.name);
-                }
-                return {
-                    packageName,
-                    success: true,
-                    skipped: false,
-                    syncedFiles,
-                };
-            }
-            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.step('Downloading', assetType);
-                let downloadedFiles;
-                if (isLocalSource && useLocalSource.docsPath) {
-                    downloadedFiles = await downloadLocalAssetFiles(useLocalSource.docsPath, assetType, filteredEntries);
-                }
-                else {
-                    const tag = options.ref ?? buildVersionTag(packageName, packageInfo.version);
-                    downloadedFiles = await downloadAssetFiles(repoInfo, assetPath, assetType, filteredEntries, tag);
-                }
-                cleanAssetDir(destDir, packageName, assetType);
-                syncedFiles[assetType] = [];
-                for (const [fileName, content] of downloadedFiles) {
-                    writeAssetFile(destDir, packageName, assetType, fileName, content);
-                    logger.file('create', fileName);
-                    syncedFiles[assetType].push(fileName);
-                }
-                writeSyncMeta(destDir, packageName, assetType, createSyncMeta(packageInfo.version, syncedFiles[assetType]));
-            }
-            return {
-                packageName,
-                success: true,
-                skipped: false,
-                syncedFiles,
-            };
-        }
-    }
-    catch (error) {
-        if (error instanceof RateLimitError)
-            return {
-                packageName,
-                success: false,
-                skipped: false,
-                reason: error.message,
-            };
-        const message = error instanceof Error ? error.message : 'Unknown error occurred';
-        return {
-            packageName,
-            success: false,
-            skipped: false,
-            reason: message,
-        };
-    }
-};
-const syncPackages = async (packages, options, cwd = process.cwd()) => {
-    const results = [];
-    const gitRoot = findGitRoot(cwd);
-    if (gitRoot)
-        logger.info(`[Output] ${gitRoot}/.claude\n`);
-    for (const packageName of packages) {
-        const result = await syncPackage(packageName, options, cwd, undefined, gitRoot ?? undefined);
-        logger.packageEnd(packageName, result);
-        results.push(result);
-    }
-    const summary = {
-        success: results.filter((r) => r.success && !r.skipped).length,
-        skipped: results.filter((r) => r.skipped).length,
-        failed: results.filter((r) => !r.success && !r.skipped).length,
-    };
-    logger.summary(summary);
-    return results;
-};
-
-export { syncPackage, syncPackages };

package/dist/core/syncMeta.cjs

@@ -1,242 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var version = require('../utils/version.cjs');
-var constants = require('./constants.cjs');
-var io = require('./io.cjs');
-
-const UNIFIED_META_PATH = constants.META_FILES.UNIFIED_SYNC_META;
-const SCHEMA_VERSION = constants.SCHEMA_VERSIONS.UNIFIED_SYNC_META;
-function readUnifiedSyncMeta(cwd) {
-    const metaPath = path.join(cwd, UNIFIED_META_PATH);
-    const meta = io.readJsonFile(metaPath);
-    if (meta && needsSkillUnitMigration(meta)) {
-        return migrateToSkillUnitSchema(meta);
-    }
-    return meta;
-}
-function writeUnifiedSyncMeta(cwd, meta) {
-    const metaPath = path.join(cwd, UNIFIED_META_PATH);
-    try {
-        io.writeJsonFile(metaPath, meta);
-    }
-    catch (error) {
-        console.error(`Failed to write unified sync meta to ${metaPath}:`, error);
-        throw error;
-    }
-}
-function updatePackageInMeta(meta, prefix, info) {
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: info,
-        },
-    };
-}
-function removePackageFromMeta(meta, prefix) {
-    const { [prefix]: removed, ...remainingPackages } = meta.packages;
-    return {
-        ...meta,
-        packages: remainingPackages,
-    };
-}
-function needsSyncUnified(meta, prefix, version$1) {
-    if (!meta) {
-        return true;
-    }
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        return true;
-    }
-    return version.needsVersionSync(version$1, pkgInfo.version);
-}
-function createEmptyUnifiedMeta() {
-    return {
-        schemaVersion: SCHEMA_VERSION,
-        syncedAt: new Date().toISOString(),
-        packages: {},
-    };
-}
-function removeSkillUnitFromPackage(meta, prefix, assetType, skillName) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    const existingUnits = (pkgInfo.files[assetType] || []);
-    const updatedUnits = existingUnits.filter((u) => u.name !== skillName);
-    if (existingUnits.length === updatedUnits.length) {
-        return meta;
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                files: {
-                    ...pkgInfo.files,
-                    [assetType]: updatedUnits,
-                },
-            },
-        },
-    };
-}
-function updatePackageVersion(meta, prefix, newVersion) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                version: newVersion,
-            },
-        },
-    };
-}
-function updatePackageFilesystemMeta(meta, prefix, assetType, updatedUnits) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        skillUnitFormat: constants.SCHEMA_VERSIONS.SKILL_UNIT_FORMAT,
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                files: {
-                    ...pkgInfo.files,
-                    [assetType]: updatedUnits,
-                },
-            },
-        },
-    };
-}
-function needsSkillUnitMigration(meta) {
-    if (meta.skillUnitFormat === constants.SCHEMA_VERSIONS.SKILL_UNIT_FORMAT) {
-        return false;
-    }
-    for (const pkgInfo of Object.values(meta.packages)) {
-        for (const rawFiles of Object.values(pkgInfo.files)) {
-            const files = rawFiles;
-            if (!Array.isArray(files) || files.length === 0) {
-                continue;
-            }
-            const first = files[0];
-            if (typeof first === 'string') {
-                return true;
-            }
-            if (typeof first === 'object' &&
-                first !== null &&
-                'original' in first &&
-                'transformed' in first &&
-                !('isDirectory' in first)) {
-                return true;
-            }
-            if (typeof first === 'object' &&
-                first !== null &&
-                'isDirectory' in first) {
-                return false;
-            }
-        }
-    }
-    return false;
-}
-function migrateToSkillUnitSchema(meta) {
-    const migratedPackages = {};
-    for (const [prefix, pkgInfo] of Object.entries(meta.packages)) {
-        const migratedFiles = {};
-        for (const [assetType, rawFiles] of Object.entries(pkgInfo.files)) {
-            const files = rawFiles;
-            if (!Array.isArray(files) || files.length === 0) {
-                migratedFiles[assetType] = [];
-                continue;
-            }
-            const first = files[0];
-            if (typeof first === 'string') {
-                migratedFiles[assetType] = files.map((name) => ({
-                    name,
-                    isDirectory: false,
-                }));
-            }
-            else if (typeof first === 'object' &&
-                first !== null &&
-                'original' in first &&
-                !('isDirectory' in first)) {
-                const fileMappings = files;
-                const groupedByDir = new Map();
-                const singleFiles = [];
-                for (const mapping of fileMappings) {
-                    const slashIndex = mapping.original.indexOf('/');
-                    if (slashIndex === -1) {
-                        singleFiles.push({
-                            name: mapping.original,
-                            isDirectory: false,
-                            transformed: mapping.transformed,
-                        });
-                    }
-                    else {
-                        const dirName = mapping.original.substring(0, slashIndex);
-                        const internalFile = mapping.original.substring(slashIndex + 1);
-                        const transformedSlashIndex = mapping.transformed.indexOf('/');
-                        const transformedDir = transformedSlashIndex !== -1
-                            ? mapping.transformed.substring(0, transformedSlashIndex)
-                            : mapping.transformed;
-                        if (!groupedByDir.has(dirName)) {
-                            groupedByDir.set(dirName, {
-                                transformed: transformedDir,
-                                internalFiles: [],
-                            });
-                        }
-                        groupedByDir.get(dirName).internalFiles.push(internalFile);
-                    }
-                }
-                const dirSkillUnits = [];
-                for (const [dirName, data] of groupedByDir.entries()) {
-                    dirSkillUnits.push({
-                        name: dirName,
-                        isDirectory: true,
-                        transformed: data.transformed,
-                        internalFiles: data.internalFiles,
-                    });
-                }
-                migratedFiles[assetType] = [...singleFiles, ...dirSkillUnits];
-            }
-            else {
-                migratedFiles[assetType] = files;
-            }
-        }
-        migratedPackages[prefix] = {
-            ...pkgInfo,
-            files: migratedFiles,
-        };
-    }
-    return {
-        ...meta,
-        skillUnitFormat: constants.SCHEMA_VERSIONS.SKILL_UNIT_FORMAT,
-        packages: migratedPackages,
-    };
-}
-
-exports.SCHEMA_VERSION = SCHEMA_VERSION;
-exports.createEmptyUnifiedMeta = createEmptyUnifiedMeta;
-exports.migrateToSkillUnitSchema = migrateToSkillUnitSchema;
-exports.needsSkillUnitMigration = needsSkillUnitMigration;
-exports.needsSyncUnified = needsSyncUnified;
-exports.readUnifiedSyncMeta = readUnifiedSyncMeta;
-exports.removePackageFromMeta = removePackageFromMeta;
-exports.removeSkillUnitFromPackage = removeSkillUnitFromPackage;
-exports.updatePackageFilesystemMeta = updatePackageFilesystemMeta;
-exports.updatePackageInMeta = updatePackageInMeta;
-exports.updatePackageVersion = updatePackageVersion;
-exports.writeUnifiedSyncMeta = writeUnifiedSyncMeta;