@slats/claude-assets-sync 0.1.4 → 0.2.0

package/dist/core/listOperations.mjs

@@ -1,205 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { syncPackage } from './sync.mjs';
-import { removeSkillUnitFromPackage, removePackageFromMeta, writeUnifiedSyncMeta } from './syncMeta.mjs';
-
-function computeFileOperations(meta, packageFiles, selectedTrees, cwd) {
-    const newPackageFiles = { ...packageFiles };
-    for (const packageTree of selectedTrees) {
-        const prefix = packageTree.id;
-        if (!newPackageFiles[prefix])
-            continue;
-        const selectedPaths = new Set();
-        if (packageTree.children) {
-            for (const assetTypeNode of packageTree.children) {
-                if (assetTypeNode.children) {
-                    for (const fileNode of assetTypeNode.children) {
-                        if (fileNode.disabled)
-                            continue;
-                        if (fileNode.selected) {
-                            selectedPaths.add(fileNode.path);
-                        }
-                    }
-                }
-            }
-        }
-        newPackageFiles[prefix] = {
-            ...newPackageFiles[prefix],
-            selected: selectedPaths,
-        };
-    }
-    const fileOperations = [];
-    const filesToDelete = [];
-    const packagesToSync = [];
-    for (const [prefix] of Object.entries(meta.packages)) {
-        const packageTree = selectedTrees.find((t) => t.id === prefix);
-        const packageInfo = meta.packages[prefix];
-        const packageData = newPackageFiles[prefix];
-        if (!packageTree || !packageTree.selected || !packageData) {
-            for (const [assetType, files] of Object.entries(packageInfo.files)) {
-                if (!Array.isArray(files))
-                    continue;
-                const units = files;
-                for (const unit of units) {
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                }
-                const firstUnit = units[0];
-                if (firstUnit?.transformed) {
-                    for (const unit of units) {
-                        const targetPath = path.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                }
-                else {
-                    const dirPath = path.join(cwd, '.claude', assetType, packageInfo.originalName);
-                    filesToDelete.push(dirPath);
-                }
-            }
-            continue;
-        }
-        let hasChanges = false;
-        const selectedByAssetType = {};
-        for (const filePath of packageData.selected) {
-            const [assetType, fileName] = filePath.split('/');
-            if (!selectedByAssetType[assetType]) {
-                selectedByAssetType[assetType] = new Set();
-            }
-            selectedByAssetType[assetType].add(fileName);
-        }
-        for (const [assetType, originalFiles] of Object.entries(packageInfo.files)) {
-            const selectedFiles = selectedByAssetType[assetType];
-            const units = Array.isArray(originalFiles)
-                ? originalFiles
-                : [];
-            const firstUnit = units[0];
-            const isFlat = !!firstUnit?.transformed;
-            if (!selectedFiles || selectedFiles.size === 0) {
-                hasChanges = true;
-                for (const unit of units) {
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                }
-                if (isFlat) {
-                    for (const unit of units) {
-                        const targetPath = path.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                }
-                else {
-                    const dirPath = path.join(cwd, '.claude', assetType, packageInfo.originalName);
-                    filesToDelete.push(dirPath);
-                }
-                continue;
-            }
-            const originalNames = new Set(units.map((u) => u.name));
-            for (const unit of units) {
-                if (!selectedFiles.has(unit.name)) {
-                    hasChanges = true;
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                    if (unit.transformed) {
-                        const targetPath = path.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                    else {
-                        const filePath = path.join(cwd, '.claude', assetType, packageInfo.originalName, unit.name);
-                        filesToDelete.push(filePath);
-                    }
-                }
-            }
-            for (const skillName of selectedFiles) {
-                if (!originalNames.has(skillName)) {
-                    hasChanges = true;
-                    fileOperations.push({
-                        type: 'add',
-                        prefix,
-                        assetType,
-                        skillName,
-                    });
-                }
-            }
-        }
-        if (hasChanges) {
-            packagesToSync.push({
-                prefix,
-                name: packageInfo.originalName,
-                local: packageInfo.local,
-            });
-        }
-    }
-    return { filesToDelete, fileOperations, packagesToSync };
-}
-async function applyChangesAndSync(changesSummary, meta, cwd, callbacks) {
-    const syncErrors = [];
-    for (const filePath of changesSummary.filesToDelete) {
-        try {
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs.rmSync(filePath, { recursive: true, force: true });
-            }
-            else {
-                fs.unlinkSync(filePath);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                console.error(`Failed to remove ${filePath}: ${error}`);
-            }
-        }
-    }
-    let updatedMeta = { ...meta };
-    const hasAddOperations = changesSummary.fileOperations.some((op) => op.type === 'add');
-    for (const op of changesSummary.fileOperations) {
-        if (op.type === 'remove') {
-            updatedMeta = removeSkillUnitFromPackage(updatedMeta, op.prefix, op.assetType, op.skillName);
-        }
-    }
-    for (const prefix of Object.keys(updatedMeta.packages)) {
-        const pkg = updatedMeta.packages[prefix];
-        if (!pkg.files || Object.keys(pkg.files).length === 0) {
-            updatedMeta = removePackageFromMeta(updatedMeta, prefix);
-        }
-    }
-    writeUnifiedSyncMeta(cwd, updatedMeta);
-    if (hasAddOperations && changesSummary.packagesToSync.length > 0) {
-        callbacks?.onSyncStart?.();
-        for (const { prefix, name, local } of changesSummary.packagesToSync) {
-            try {
-                const removedFiles = changesSummary.fileOperations
-                    .filter((op) => op.type === 'remove' && op.prefix === prefix)
-                    .map((op) => `${op.assetType}/${op.skillName}`);
-                const exclusions = removedFiles.length > 0
-                    ? { directories: [], files: removedFiles }
-                    : undefined;
-                await syncPackage(name, {
-                    force: true,
-                    dryRun: false,
-                    local: local ?? false,
-                    ref: undefined,
-                    flat: undefined,
-                }, cwd, exclusions);
-            }
-            catch (error) {
-                const msg = `Failed to sync ${name}: ${error}`;
-                console.error(msg);
-                syncErrors.push(msg);
-            }
-        }
-    }
-    return { updatedMeta, syncErrors };
-}
-
-export { applyChangesAndSync, computeFileOperations };

package/dist/core/localSource.cjs

@@ -1,126 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var _package = require('../utils/package.cjs');
-
-const canUseLocalSource = (packageName, requestedVersion, assetPath, cwd) => {
-    const packagePath = _package.resolvePackagePath(packageName, cwd);
-    if (!packagePath) {
-        return {
-            available: false,
-            reason: `Package ${packageName} not found in node_modules`,
-        };
-    }
-    const docsPath = path.join(packagePath, assetPath);
-    if (!fs.existsSync(docsPath)) {
-        return {
-            available: false,
-            reason: `Local docs path not found: ${docsPath}`,
-        };
-    }
-    try {
-        const pkgJsonPath = path.join(packagePath, 'package.json');
-        const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-        if (pkgJson.version !== requestedVersion) {
-            return {
-                available: false,
-                reason: `Version mismatch: installed=${pkgJson.version}, requested=${requestedVersion}`,
-            };
-        }
-    }
-    catch {
-        return {
-            available: false,
-            reason: 'Failed to read package.json from node_modules',
-        };
-    }
-    return { available: true, docsPath };
-};
-const fetchLocalDirectoryContents = (dirPath) => {
-    if (!fs.existsSync(dirPath))
-        return null;
-    try {
-        const entries = fs.readdirSync(dirPath);
-        const result = [];
-        for (const name of entries) {
-            const fullPath = path.join(dirPath, name);
-            const stat = fs.statSync(fullPath);
-            if (stat.isDirectory()) {
-                result.push({
-                    name,
-                    path: fullPath,
-                    type: 'dir',
-                    download_url: null,
-                    sha: '',
-                });
-            }
-            else if (stat.isFile() && name.endsWith('.md')) {
-                result.push({
-                    name,
-                    path: fullPath,
-                    type: 'file',
-                    download_url: null,
-                    sha: '',
-                });
-            }
-        }
-        return result;
-    }
-    catch {
-        return null;
-    }
-};
-const expandLocalDirectoryEntries = (dirPath, entries, prefix = '') => {
-    const result = [];
-    for (const entry of entries) {
-        const entryPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.type === 'file') {
-            result.push({
-                ...entry,
-                name: prefix ? entryPrefix : entry.name,
-            });
-        }
-        else if (entry.type === 'dir') {
-            const subDirPath = path.join(dirPath, entry.name);
-            const subEntries = fetchLocalDirectoryContents(subDirPath);
-            if (subEntries) {
-                const expanded = expandLocalDirectoryEntries(subDirPath, subEntries, entryPrefix);
-                result.push(...expanded);
-            }
-        }
-    }
-    return result;
-};
-const fetchLocalAssetFiles = async (docsBasePath, assetTypes) => {
-    const assetFiles = {};
-    for (const assetType of assetTypes) {
-        const assetDirPath = path.join(docsBasePath, assetType);
-        const entries = fetchLocalDirectoryContents(assetDirPath);
-        if (!entries) {
-            assetFiles[assetType] = [];
-            continue;
-        }
-        assetFiles[assetType] = expandLocalDirectoryEntries(assetDirPath, entries);
-    }
-    return assetFiles;
-};
-const downloadLocalAssetFiles = async (docsBasePath, assetType, entries) => {
-    const results = new Map();
-    for (const entry of entries) {
-        const filePath = path.join(docsBasePath, assetType, entry.name);
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            results.set(entry.name, content);
-        }
-        catch {
-        }
-    }
-    return results;
-};
-
-exports.canUseLocalSource = canUseLocalSource;
-exports.downloadLocalAssetFiles = downloadLocalAssetFiles;
-exports.expandLocalDirectoryEntries = expandLocalDirectoryEntries;
-exports.fetchLocalAssetFiles = fetchLocalAssetFiles;
-exports.fetchLocalDirectoryContents = fetchLocalDirectoryContents;

package/dist/core/localSource.d.ts

@@ -1,33 +0,0 @@
-import type { AssetType, GitHubEntry } from '../utils/types.js';
-export interface LocalSourceResult {
-    available: boolean;
-    docsPath?: string;
-    reason?: string;
-}
-/**
- * Check if local docs source is available in node_modules.
- * Returns available=true if:
- * 1. node_modules/<packageName>/<assetPath> directory exists
- * 2. Installed version matches requestedVersion
- */
-export declare const canUseLocalSource: (packageName: string, requestedVersion: string, assetPath: string, cwd: string) => LocalSourceResult;
-/**
- * Read directory contents and return .md files and subdirs in GitHubEntry format.
- * Returns null if the directory doesn't exist.
- */
-export declare const fetchLocalDirectoryContents: (dirPath: string) => GitHubEntry[] | null;
-/**
- * Recursively expand directory entries into flat file entries with path prefixes.
- * Mirrors github.ts expandDirectoryEntries behaviour but reads from local filesystem.
- */
-export declare const expandLocalDirectoryEntries: (dirPath: string, entries: GitHubEntry[], prefix?: string) => GitHubEntry[];
-/**
- * Fetch asset files from local filesystem.
- * Mirrors github.ts fetchAssetFiles but reads from node_modules instead of GitHub API.
- */
-export declare const fetchLocalAssetFiles: (docsBasePath: string, assetTypes: string[]) => Promise<Record<string, GitHubEntry[]>>;
-/**
- * Read file contents from local filesystem for the given entries.
- * Mirrors github.ts downloadAssetFiles but reads local files instead of HTTP requests.
- */
-export declare const downloadLocalAssetFiles: (docsBasePath: string, assetType: AssetType, entries: GitHubEntry[]) => Promise<Map<string, string>>;

package/dist/core/localSource.mjs

@@ -1,120 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolvePackagePath } from '../utils/package.mjs';
-
-const canUseLocalSource = (packageName, requestedVersion, assetPath, cwd) => {
-    const packagePath = resolvePackagePath(packageName, cwd);
-    if (!packagePath) {
-        return {
-            available: false,
-            reason: `Package ${packageName} not found in node_modules`,
-        };
-    }
-    const docsPath = join(packagePath, assetPath);
-    if (!existsSync(docsPath)) {
-        return {
-            available: false,
-            reason: `Local docs path not found: ${docsPath}`,
-        };
-    }
-    try {
-        const pkgJsonPath = join(packagePath, 'package.json');
-        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
-        if (pkgJson.version !== requestedVersion) {
-            return {
-                available: false,
-                reason: `Version mismatch: installed=${pkgJson.version}, requested=${requestedVersion}`,
-            };
-        }
-    }
-    catch {
-        return {
-            available: false,
-            reason: 'Failed to read package.json from node_modules',
-        };
-    }
-    return { available: true, docsPath };
-};
-const fetchLocalDirectoryContents = (dirPath) => {
-    if (!existsSync(dirPath))
-        return null;
-    try {
-        const entries = readdirSync(dirPath);
-        const result = [];
-        for (const name of entries) {
-            const fullPath = join(dirPath, name);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                result.push({
-                    name,
-                    path: fullPath,
-                    type: 'dir',
-                    download_url: null,
-                    sha: '',
-                });
-            }
-            else if (stat.isFile() && name.endsWith('.md')) {
-                result.push({
-                    name,
-                    path: fullPath,
-                    type: 'file',
-                    download_url: null,
-                    sha: '',
-                });
-            }
-        }
-        return result;
-    }
-    catch {
-        return null;
-    }
-};
-const expandLocalDirectoryEntries = (dirPath, entries, prefix = '') => {
-    const result = [];
-    for (const entry of entries) {
-        const entryPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.type === 'file') {
-            result.push({
-                ...entry,
-                name: prefix ? entryPrefix : entry.name,
-            });
-        }
-        else if (entry.type === 'dir') {
-            const subDirPath = join(dirPath, entry.name);
-            const subEntries = fetchLocalDirectoryContents(subDirPath);
-            if (subEntries) {
-                const expanded = expandLocalDirectoryEntries(subDirPath, subEntries, entryPrefix);
-                result.push(...expanded);
-            }
-        }
-    }
-    return result;
-};
-const fetchLocalAssetFiles = async (docsBasePath, assetTypes) => {
-    const assetFiles = {};
-    for (const assetType of assetTypes) {
-        const assetDirPath = join(docsBasePath, assetType);
-        const entries = fetchLocalDirectoryContents(assetDirPath);
-        if (!entries) {
-            assetFiles[assetType] = [];
-            continue;
-        }
-        assetFiles[assetType] = expandLocalDirectoryEntries(assetDirPath, entries);
-    }
-    return assetFiles;
-};
-const downloadLocalAssetFiles = async (docsBasePath, assetType, entries) => {
-    const results = new Map();
-    for (const entry of entries) {
-        const filePath = join(docsBasePath, assetType, entry.name);
-        try {
-            const content = readFileSync(filePath, 'utf-8');
-            results.set(entry.name, content);
-        }
-        catch {
-        }
-    }
-    return results;
-};
-
-export { canUseLocalSource, downloadLocalAssetFiles, expandLocalDirectoryEntries, fetchLocalAssetFiles, fetchLocalDirectoryContents };

package/dist/core/migration.cjs

@@ -1,201 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var nameTransform = require('../utils/nameTransform.cjs');
-var packageName = require('../utils/packageName.cjs');
-var filesystem = require('./filesystem.cjs');
-var syncMeta = require('./syncMeta.cjs');
-
-function needsMigration(cwd) {
-    const assetTypes = ['commands', 'skills'];
-    for (const assetType of assetTypes) {
-        const assetDir = path.join(cwd, '.claude', assetType);
-        if (!fs.existsSync(assetDir)) {
-            continue;
-        }
-        try {
-            const entries = fs.readdirSync(assetDir);
-            for (const entry of entries) {
-                if (entry.startsWith('@')) {
-                    const scopeDir = path.join(assetDir, entry);
-                    if (fs.statSync(scopeDir).isDirectory()) {
-                        return true;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error scanning ${assetDir}:`, error);
-            continue;
-        }
-    }
-    return false;
-}
-async function migrateToFlat(cwd, options = {}) {
-    const { dryRun = false } = options;
-    const migratedPackages = [];
-    const errors = [];
-    console.log(`\n🔄 Starting migration to flat structure${dryRun ? ' (DRY RUN)' : ''}...`);
-    let unifiedMeta = syncMeta.readUnifiedSyncMeta(cwd);
-    if (!unifiedMeta) {
-        console.log('📝 Creating new unified sync metadata');
-        unifiedMeta = syncMeta.createEmptyUnifiedMeta();
-    }
-    const assetTypes = ['commands', 'skills'];
-    const legacyDirs = [];
-    for (const assetType of assetTypes) {
-        const assetDir = path.join(cwd, '.claude', assetType);
-        if (!fs.existsSync(assetDir)) {
-            continue;
-        }
-        console.log(`\n📂 Scanning ${assetType}...`);
-        try {
-            const scopeDirs = fs.readdirSync(assetDir).filter((entry) => {
-                const fullPath = path.join(assetDir, entry);
-                return entry.startsWith('@') && fs.statSync(fullPath).isDirectory();
-            });
-            for (const scopeDir of scopeDirs) {
-                const scopePath = path.join(assetDir, scopeDir);
-                const packageDirs = fs.readdirSync(scopePath).filter((entry) => {
-                    const fullPath = path.join(scopePath, entry);
-                    return fs.statSync(fullPath).isDirectory();
-                });
-                for (const packageDir of packageDirs) {
-                    const packagePath = path.join(scopePath, packageDir);
-                    const packageName$1 = `${scopeDir}/${packageDir}`;
-                    console.log(`  📦 Processing ${packageName$1}...`);
-                    try {
-                        const metaPath = path.join(packagePath, '.sync-meta.json');
-                        let legacyMeta = null;
-                        if (fs.existsSync(metaPath)) {
-                            const metaContent = fs.readFileSync(metaPath, 'utf-8');
-                            legacyMeta = JSON.parse(metaContent);
-                        }
-                        if (!legacyMeta) {
-                            console.log(`    ⚠️  No .sync-meta.json found, skipping`);
-                            continue;
-                        }
-                        const prefix = packageName.packageNameToPrefix(packageName$1);
-                        const commandUnits = [];
-                        const skillUnits = [];
-                        for (const fileName of legacyMeta.files) {
-                            const sourcePath = path.join(packagePath, fileName);
-                            if (!fs.existsSync(sourcePath)) {
-                                console.log(`    ⚠️  File not found: ${fileName}`);
-                                continue;
-                            }
-                            if (assetType === 'commands') {
-                                if (!dryRun) {
-                                    const content = fs.readFileSync(sourcePath, 'utf-8');
-                                    filesystem.writeFlatAssetFile(cwd, assetType, fileName, content);
-                                    console.log(`    ✅ Migrated: ${fileName}`);
-                                }
-                                else {
-                                    console.log(`    🔍 Would migrate: ${fileName}`);
-                                }
-                                commandUnits.push({ name: fileName, isDirectory: false });
-                            }
-                            else {
-                                const flatFileName = nameTransform.toFlatFileName(prefix, fileName);
-                                if (!dryRun) {
-                                    const content = fs.readFileSync(sourcePath, 'utf-8');
-                                    filesystem.writeFlatAssetFile(cwd, assetType, flatFileName, content);
-                                    console.log(`    ✅ Migrated: ${fileName} → ${flatFileName}`);
-                                }
-                                else {
-                                    console.log(`    🔍 Would migrate: ${fileName} → ${flatFileName}`);
-                                }
-                                skillUnits.push({
-                                    name: fileName,
-                                    isDirectory: false,
-                                    transformed: flatFileName,
-                                });
-                            }
-                        }
-                        const packageInfo = {
-                            originalName: packageName$1,
-                            version: legacyMeta.version,
-                            files: {
-                                commands: assetType === 'commands' ? commandUnits : [],
-                                skills: assetType === 'skills' ? skillUnits : [],
-                                agents: [],
-                            },
-                        };
-                        if (unifiedMeta.packages[prefix]) {
-                            const existing = unifiedMeta.packages[prefix];
-                            if (assetType === 'commands') {
-                                packageInfo.files.skills = existing.files.skills;
-                                packageInfo.files.agents = existing.files.agents;
-                            }
-                            else if (assetType === 'skills') {
-                                packageInfo.files.commands = existing.files.commands;
-                                packageInfo.files.agents = existing.files.agents;
-                            }
-                            else {
-                                packageInfo.files.commands = existing.files.commands;
-                                packageInfo.files.skills = existing.files.skills;
-                            }
-                        }
-                        unifiedMeta = syncMeta.updatePackageInMeta(unifiedMeta, prefix, packageInfo);
-                        migratedPackages.push(packageName$1);
-                        legacyDirs.push(packagePath);
-                    }
-                    catch (error) {
-                        const errorMsg = `Failed to migrate ${packageName$1}: ${error}`;
-                        console.error(`    ❌ ${errorMsg}`);
-                        errors.push(errorMsg);
-                    }
-                }
-                legacyDirs.push(scopePath);
-            }
-        }
-        catch (error) {
-            const errorMsg = `Error scanning ${assetType}: ${error}`;
-            console.error(`❌ ${errorMsg}`);
-            errors.push(errorMsg);
-        }
-    }
-    if (!dryRun && migratedPackages.length > 0) {
-        syncMeta.writeUnifiedSyncMeta(cwd, unifiedMeta);
-        console.log(`\n💾 Updated unified sync metadata`);
-    }
-    if (!dryRun && legacyDirs.length > 0) {
-        console.log(`\n🧹 Cleaning up legacy directories...`);
-        for (const legacyDir of legacyDirs) {
-            try {
-                if (fs.existsSync(legacyDir)) {
-                    const entries = fs.readdirSync(legacyDir);
-                    const hasOnlyMeta = entries.length === 1 && entries[0] === '.sync-meta.json';
-                    const isEmpty = entries.length === 0;
-                    if (isEmpty || hasOnlyMeta) {
-                        fs.rmSync(legacyDir, { recursive: true, force: true });
-                        console.log(`  ✅ Removed: ${legacyDir}`);
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`  ⚠️  Failed to remove ${legacyDir}:`, error);
-            }
-        }
-    }
-    console.log(`\n📊 Migration Summary:`);
-    console.log(`  ✅ Migrated packages: ${migratedPackages.length}`);
-    if (errors.length > 0) {
-        console.log(`  ❌ Errors: ${errors.length}`);
-    }
-    if (dryRun) {
-        console.log(`\n🔍 DRY RUN: No changes were made. Run without --dry-run to apply migration.`);
-    }
-    else if (migratedPackages.length > 0) {
-        console.log(`\n✨ Migration completed successfully!`);
-    }
-    return {
-        success: errors.length === 0,
-        migratedPackages,
-        errors: errors.length > 0 ? errors : undefined,
-    };
-}
-
-exports.migrateToFlat = migrateToFlat;
-exports.needsMigration = needsMigration;