@slats/claude-assets-sync 0.1.0 → 0.1.1

package/dist/core/listOperations.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var sync = require('./sync.cjs');
+var syncMeta = require('./syncMeta.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+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__namespace.join(cwd, '.claude', assetType, unit.transformed);
+                        filesToDelete.push(targetPath);
+                    }
+                }
+                else {
+                    const dirPath = path__namespace.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__namespace.join(cwd, '.claude', assetType, unit.transformed);
+                        filesToDelete.push(targetPath);
+                    }
+                }
+                else {
+                    const dirPath = path__namespace.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__namespace.join(cwd, '.claude', assetType, unit.transformed);
+                        filesToDelete.push(targetPath);
+                    }
+                    else {
+                        const filePath = path__namespace.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__namespace.statSync(filePath);
+            if (stat.isDirectory()) {
+                fs__namespace.rmSync(filePath, { recursive: true, force: true });
+            }
+            else {
+                fs__namespace.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 = syncMeta.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 = syncMeta.removePackageFromMeta(updatedMeta, prefix);
+        }
+    }
+    syncMeta.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 sync.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 };
+}
+
+exports.applyChangesAndSync = applyChangesAndSync;
+exports.computeFileOperations = computeFileOperations;

package/dist/core/listOperations.d.ts

@@ -0,0 +1,43 @@
+import type { TreeNode, UnifiedSyncMeta } from '../utils/types.js';
+export type FileOperation = {
+    type: 'add';
+    prefix: string;
+    assetType: string;
+    skillName: string;
+} | {
+    type: 'remove';
+    prefix: string;
+    assetType: string;
+    skillName: string;
+};
+export interface ChangesSummary {
+    filesToDelete: string[];
+    fileOperations: FileOperation[];
+    packagesToSync: Array<{
+        prefix: string;
+        name: string;
+        local?: boolean;
+    }>;
+}
+export interface PackageFiles {
+    [prefix: string]: {
+        available: TreeNode[];
+        selected: Set<string>;
+    };
+}
+/**
+ * Pure computation: given current meta, packageFiles, and selected trees,
+ * compute what file operations need to happen.
+ * No React state, no side effects.
+ */
+export declare function computeFileOperations(meta: UnifiedSyncMeta, packageFiles: PackageFiles, selectedTrees: TreeNode[], cwd: string): ChangesSummary;
+/**
+ * Apply file changes and sync packages.
+ * Has side effects (filesystem writes, sync calls) but NO React/ink dependencies.
+ */
+export declare function applyChangesAndSync(changesSummary: ChangesSummary, meta: UnifiedSyncMeta, cwd: string, callbacks?: {
+    onSyncStart?: () => void;
+}): Promise<{
+    updatedMeta: UnifiedSyncMeta;
+    syncErrors: string[];
+}>;

package/dist/core/listOperations.mjs

@@ -0,0 +1,205 @@
+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/packageScanner.cjs

@@ -39,10 +39,11 @@ async function scanLocalAssets(packageName, cwd) {
         throw new Error(`Package ${packageName} not found in local workspace`);
     }
     const pkgInfo = readPackageJsonFromPath(packagePath);
-    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
-        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    if (!pkgInfo) {
+        throw new Error(`Package ${packageName} not found in local workspace`);
     }
-    const assetPath = path.join(packagePath, pkgInfo.claude.assetPath);
+    const claudeConfig = _package.resolveClaudeConfig(pkgInfo.claude);
+    const assetPath = path.join(packagePath, claudeConfig.assetPath);
     if (!fs.existsSync(assetPath)) {
         throw new Error(`Asset path ${assetPath} does not exist`);
     }
@@ -62,10 +63,11 @@ async function scanLocalAssets(packageName, cwd) {
 async function scanRemoteAssets(packageName, ref) {
     const nodeModulesPath = path.join(process.cwd(), 'node_modules', packageName);
     const pkgInfo = readPackageJsonFromPath(nodeModulesPath);
-    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
-        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    if (!pkgInfo) {
+        throw new Error(`Package ${packageName} not found`);
     }
-    const assetBasePath = pkgInfo.claude.assetPath;
+    const claudeConfig = _package.resolveClaudeConfig(pkgInfo.claude);
+    const assetBasePath = claudeConfig.assetPath;
     if (!ref) {
         const localDocsPath = path.join(nodeModulesPath, assetBasePath);
         if (fs.existsSync(localDocsPath)) {

package/dist/core/packageScanner.mjs

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { toFlatFileName } from '../utils/nameTransform.mjs';
-import { parseGitHubRepo } from '../utils/package.mjs';
+import { resolveClaudeConfig, parseGitHubRepo } from '../utils/package.mjs';
 import { DEFAULT_ASSET_TYPES } from './constants.mjs';
 import { fetchDirectoryContents } from './github.mjs';
 
@@ -37,10 +37,11 @@ async function scanLocalAssets(packageName, cwd) {
         throw new Error(`Package ${packageName} not found in local workspace`);
     }
     const pkgInfo = readPackageJsonFromPath(packagePath);
-    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
-        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    if (!pkgInfo) {
+        throw new Error(`Package ${packageName} not found in local workspace`);
     }
-    const assetPath = join(packagePath, pkgInfo.claude.assetPath);
+    const claudeConfig = resolveClaudeConfig(pkgInfo.claude);
+    const assetPath = join(packagePath, claudeConfig.assetPath);
     if (!existsSync(assetPath)) {
         throw new Error(`Asset path ${assetPath} does not exist`);
     }
@@ -60,10 +61,11 @@ async function scanLocalAssets(packageName, cwd) {
 async function scanRemoteAssets(packageName, ref) {
     const nodeModulesPath = join(process.cwd(), 'node_modules', packageName);
     const pkgInfo = readPackageJsonFromPath(nodeModulesPath);
-    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
-        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    if (!pkgInfo) {
+        throw new Error(`Package ${packageName} not found`);
     }
-    const assetBasePath = pkgInfo.claude.assetPath;
+    const claudeConfig = resolveClaudeConfig(pkgInfo.claude);
+    const assetBasePath = claudeConfig.assetPath;
     if (!ref) {
         const localDocsPath = join(nodeModulesPath, assetBasePath);
         if (existsSync(localDocsPath)) {

package/dist/core/sync.cjs

@@ -60,13 +60,7 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                 reason: `Package not found in ${location}`,
             };
         }
-        if (!packageInfo.claude?.assetPath)
-            return {
-                packageName: packageName$1,
-                success: false,
-                skipped: true,
-                reason: 'Package does not have claude.assetPath in package.json',
-            };
+        const claudeConfig = _package.resolveClaudeConfig(packageInfo.claude);
         const repoInfo = _package.parseGitHubRepo(packageInfo.repository);
         const useFlat = options.flat !== false;
         if (useFlat) {
@@ -81,11 +75,11 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                     reason: `Already synced at version ${packageInfo.version}`,
                 };
             }
-            const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
+            const assetPath = _package.buildAssetPath(claudeConfig.assetPath);
             const useLocalSource = options.ref
                 ? { available: false }
                 : localSource.canUseLocalSource(packageName$1, packageInfo.version, assetPath, cwd);
-            const assetTypes = _package.getAssetTypes(packageInfo.claude);
+            const assetTypes = _package.getAssetTypes(claudeConfig);
             let assetFiles;
             let isLocalSource;
             if (useLocalSource.available && useLocalSource.docsPath) {
@@ -135,7 +129,7 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                 });
                 if (filteredEntries.length === 0)
                     continue;
-                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                const structure = assetStructure.getAssetStructure(assetType, claudeConfig);
                 if (structure === 'nested') {
                     fileMappings[assetType] = filteredEntries.map((e) => ({
                         name: e.name,
@@ -151,7 +145,7 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                     const units = fileMappings[assetType];
                     if (!units || units.length === 0)
                         continue;
-                    const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                    const structure = assetStructure.getAssetStructure(assetType, claudeConfig);
                     if (structure === 'nested') {
                         logger.logger.step(`Would sync ${assetType} to`, paths.getDestinationDir(destDir, packageName$1, assetType));
                         units.forEach((unit) => {
@@ -181,7 +175,7 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                 };
             }
             for (const assetType of assetTypes) {
-                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                const structure = assetStructure.getAssetStructure(assetType, claudeConfig);
                 if (structure === 'nested') {
                     filesystem.cleanAssetDir(destDir, packageName$1, assetType);
                 }
@@ -201,7 +195,7 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
                 });
                 if (filteredEntries.length === 0)
                     continue;
-                const structure = assetStructure.getAssetStructure(assetType, packageInfo.claude);
+                const structure = assetStructure.getAssetStructure(assetType, claudeConfig);
                 logger.logger.step('Downloading', assetType);
                 let downloadedFiles;
                 if (isLocalSource && useLocalSource.docsPath) {
@@ -252,11 +246,11 @@ const syncPackage = async (packageName$1, options, cwd = process.cwd(), exclusio
             };
         }
         else {
-            const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
+            const assetPath = _package.buildAssetPath(claudeConfig.assetPath);
             const useLocalSource = options.ref
                 ? { available: false }
                 : localSource.canUseLocalSource(packageName$1, packageInfo.version, assetPath, cwd);
-            const assetTypes = _package.getAssetTypes(packageInfo.claude);
+            const assetTypes = _package.getAssetTypes(claudeConfig);
             let assetFiles;
             let isLocalSource;
             if (useLocalSource.available && useLocalSource.docsPath) {