@slats/claude-assets-sync 0.0.3 → 0.0.5

package/dist/commands/add.cjs

@@ -38,13 +38,8 @@ async function performSync(selection, cwd) {
         files: [],
     };
     for (const assetType of Object.keys(selection.excludedAssets)) {
-        for (const path of selection.excludedAssets[assetType]) {
-            if (path.includes('.')) {
-                exclusions.files.push(path);
-            }
-            else {
-                exclusions.directories.push(path);
-            }
+        for (const excludedPath of selection.excludedAssets[assetType]) {
+            exclusions.files.push(excludedPath);
         }
     }
     await sync.syncPackage(selection.packageName, {

package/dist/commands/add.mjs

@@ -36,13 +36,8 @@ async function performSync(selection, cwd) {
         files: [],
     };
     for (const assetType of Object.keys(selection.excludedAssets)) {
-        for (const path of selection.excludedAssets[assetType]) {
-            if (path.includes('.')) {
-                exclusions.files.push(path);
-            }
-            else {
-                exclusions.directories.push(path);
-            }
+        for (const excludedPath of selection.excludedAssets[assetType]) {
+            exclusions.files.push(excludedPath);
         }
     }
     await syncPackage(selection.packageName, {

package/dist/commands/index.d.ts

@@ -8,7 +8,9 @@ export { runRemoveCommand } from './remove';
 export { runStatusCommand } from './status';
 export { runMigrateCommand } from './migrate';
 export { runAddCommand } from './add';
+export { runUpdateCommand } from './update';
 export type { AddCommandOptions } from './add';
+export type { UpdateCommandOptions } from './update';
 /**
  * Command metadata for CLI help and documentation
  */
@@ -88,4 +90,24 @@ export declare const COMMANDS: {
             readonly description: "Preview migration without making changes";
         }];
     };
+    readonly update: {
+        readonly name: "update";
+        readonly description: "Update package metadata in .sync-meta.json";
+        readonly options: readonly [{
+            readonly flag: "-p, --package <name>";
+            readonly description: "Package name to update (default: all)";
+        }, {
+            readonly flag: "-l, --local";
+            readonly description: "Read from local workspace";
+        }, {
+            readonly flag: "-r, --ref <ref>";
+            readonly description: "Git ref to fetch from";
+        }, {
+            readonly flag: "--dry-run";
+            readonly description: "Preview changes without writing";
+        }, {
+            readonly flag: "--sync";
+            readonly description: "Re-sync files after updating metadata";
+        }];
+    };
 };

package/dist/commands/remove.cjs

@@ -6,7 +6,7 @@ var readline = require('node:readline/promises');
 var pc = require('picocolors');
 var syncMeta = require('../core/syncMeta.cjs');
 var logger = require('../utils/logger.cjs');
-var nameTransform = require('../utils/nameTransform.cjs');
+var packageName = require('../utils/packageName.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -30,17 +30,17 @@ var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
-    const { package: packageName, yes, dryRun } = options;
-    const prefix = nameTransform.packageNameToPrefix(packageName);
+    const { package: packageName$1, yes, dryRun } = options;
+    const prefix = packageName.packageNameToPrefix(packageName$1);
     const meta = syncMeta.readUnifiedSyncMeta(cwd);
     if (!meta || !meta.packages || !meta.packages[prefix]) {
-        logger.logger.error(`Package ${packageName} is not synced.`);
+        logger.logger.error(`Package ${packageName$1} is not synced.`);
         process.exit(1);
         return;
     }
     const packageInfo = meta.packages[prefix];
     if (!packageInfo || !packageInfo.files) {
-        logger.logger.error(`Package ${packageName} has no files to remove.`);
+        logger.logger.error(`Package ${packageName$1} has no files to remove.`);
         process.exit(1);
         return;
     }
@@ -48,16 +48,16 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
     for (const [assetType, files] of Object.entries(packageInfo.files)) {
         if (!Array.isArray(files) || files.length === 0)
             continue;
-        const firstFile = files[0];
-        const isFlat = typeof firstFile === 'object' && 'transformed' in firstFile;
-        if (isFlat) {
-            for (const file of files) {
-                const filePath = path__namespace.join(cwd, '.claude', assetType, file.transformed);
-                filesToRemove.push({ assetType, path: filePath });
+        const units = files;
+        const firstUnit = units[0];
+        if (firstUnit.transformed) {
+            for (const unit of units) {
+                const targetPath = path__namespace.join(cwd, '.claude', assetType, unit.transformed);
+                filesToRemove.push({ assetType, path: targetPath });
             }
         }
         else {
-            const dirPath = path__namespace.join(cwd, '.claude', assetType, packageName);
+            const dirPath = path__namespace.join(cwd, '.claude', assetType, packageName$1);
             filesToRemove.push({ assetType, path: dirPath });
         }
     }
@@ -103,7 +103,7 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
     delete meta.packages[prefix];
     meta.syncedAt = new Date().toISOString();
     syncMeta.writeUnifiedSyncMeta(cwd, meta);
-    logger.logger.success(`\nRemoved package ${packageName}`);
+    logger.logger.success(`\nRemoved package ${packageName$1}`);
 };
 
 exports.runRemoveCommand = runRemoveCommand;

package/dist/commands/remove.mjs

@@ -4,7 +4,7 @@ import * as readline from 'node:readline/promises';
 import pc from 'picocolors';
 import { readUnifiedSyncMeta, writeUnifiedSyncMeta } from '../core/syncMeta.mjs';
 import { logger } from '../utils/logger.mjs';
-import { packageNameToPrefix } from '../utils/nameTransform.mjs';
+import { packageNameToPrefix } from '../utils/packageName.mjs';
 
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName, yes, dryRun } = options;
@@ -25,12 +25,12 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
     for (const [assetType, files] of Object.entries(packageInfo.files)) {
         if (!Array.isArray(files) || files.length === 0)
             continue;
-        const firstFile = files[0];
-        const isFlat = typeof firstFile === 'object' && 'transformed' in firstFile;
-        if (isFlat) {
-            for (const file of files) {
-                const filePath = path.join(cwd, '.claude', assetType, file.transformed);
-                filesToRemove.push({ assetType, path: filePath });
+        const units = files;
+        const firstUnit = units[0];
+        if (firstUnit.transformed) {
+            for (const unit of units) {
+                const targetPath = path.join(cwd, '.claude', assetType, unit.transformed);
+                filesToRemove.push({ assetType, path: targetPath });
             }
         }
         else {

package/dist/commands/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Common types for command modules
  */
+import type { SkillUnit } from '../utils/types';
 /**
  * Base command result
  */
@@ -65,10 +66,7 @@ export interface PackageStatusItem {
     upToDate: boolean;
     syncedAt: string;
     error?: string;
-    files: Record<string, Array<string | {
-        original: string;
-        transformed: string;
-    }>>;
+    files: Record<string, SkillUnit[]>;
     fileCount: number;
 }
 /**

package/dist/commands/update.cjs

@@ -0,0 +1,178 @@
+'use strict';
+
+var pc = require('picocolors');
+var packageScanner = require('../core/packageScanner.cjs');
+var sync = require('../core/sync.cjs');
+var syncMeta = require('../core/syncMeta.cjs');
+var constants = require('../core/constants.cjs');
+var logger = require('../utils/logger.cjs');
+var _package = require('../utils/package.cjs');
+var packageName = require('../utils/packageName.cjs');
+
+const runUpdateCommand = async (options, cwd = process.cwd()) => {
+    const destDir = _package.findGitRoot(cwd) ?? cwd;
+    const meta = syncMeta.readUnifiedSyncMeta(destDir);
+    if (!meta || Object.keys(meta.packages).length === 0) {
+        logger.logger.info('No packages synced yet. Use "sync" or "add" first.');
+        return;
+    }
+    const packagesToUpdate = [];
+    if (options.package) {
+        const prefix = packageName.packageNameToPrefix(options.package);
+        if (!meta.packages[prefix]) {
+            logger.logger.error(`Package ${options.package} is not synced.`);
+            process.exit(1);
+            return;
+        }
+        packagesToUpdate.push(prefix);
+    }
+    else {
+        packagesToUpdate.push(...Object.keys(meta.packages));
+    }
+    let updatedMeta = { ...meta };
+    let hasChanges = false;
+    for (const prefix of packagesToUpdate) {
+        const packageInfo = updatedMeta.packages[prefix];
+        const packageName = packageInfo.originalName;
+        console.log(pc.cyan(`\nUpdating ${packageName}...`));
+        const isLocal = options.local ?? packageInfo.local ?? false;
+        const currentPkgInfo = isLocal
+            ? _package.readLocalPackageJson(packageName, cwd)
+            : _package.readPackageJson(packageName, cwd);
+        if (!currentPkgInfo) {
+            const location = isLocal ? 'workspace' : 'node_modules';
+            console.log(pc.yellow(`  ⚠ Package not found in ${location}, skipping version update`));
+        }
+        else {
+            const newVersion = currentPkgInfo.version;
+            if (newVersion !== packageInfo.version) {
+                if (options.dryRun) {
+                    console.log(pc.gray(`  [DRY RUN] Would update version: ${packageInfo.version} → ${newVersion}`));
+                }
+                else {
+                    updatedMeta = syncMeta.updatePackageVersion(updatedMeta, prefix, newVersion);
+                    console.log(pc.green(`  ✓ Version updated: ${packageInfo.version} → ${newVersion}`));
+                    hasChanges = true;
+                }
+            }
+            else {
+                console.log(pc.gray(`  Version unchanged: ${packageInfo.version}`));
+            }
+        }
+        try {
+            const scannedTrees = await packageScanner.scanPackageAssets(packageName, {
+                local: isLocal,
+                ref: options.ref,
+                cwd,
+            });
+            if (scannedTrees && scannedTrees.length > 0) {
+                for (const assetTypeTree of scannedTrees) {
+                    const assetType = assetTypeTree.label;
+                    const scannedUnits = packageScanner.buildSkillUnitsFromTree(assetTypeTree, prefix);
+                    const currentUnits = packageInfo.files[assetType] || [];
+                    const scannedNames = new Set(scannedUnits.map((u) => u.name));
+                    const currentNames = new Set(currentUnits.map((u) => u.name));
+                    const added = scannedUnits.filter((u) => !currentNames.has(u.name));
+                    const removed = currentUnits.filter((u) => !scannedNames.has(u.name));
+                    const unchanged = currentUnits.filter((u) => scannedNames.has(u.name));
+                    if (added.length > 0 || removed.length > 0) {
+                        const mergedUnits = [...unchanged, ...added];
+                        if (options.dryRun) {
+                            if (added.length > 0) {
+                                console.log(pc.gray(`  [DRY RUN] ${assetType}: ${added.length} new skill(s) found`));
+                                for (const u of added) {
+                                    console.log(pc.gray(`    + ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            if (removed.length > 0) {
+                                console.log(pc.yellow(`  [DRY RUN] ${assetType}: ${removed.length} skill(s) no longer in upstream`));
+                                for (const u of removed) {
+                                    console.log(pc.yellow(`    - ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                        }
+                        else {
+                            updatedMeta = syncMeta.updatePackageFilesystemMeta(updatedMeta, prefix, assetType, mergedUnits);
+                            if (added.length > 0) {
+                                console.log(pc.green(`  ✓ ${assetType}: ${added.length} new skill(s) added to meta`));
+                                for (const u of added) {
+                                    console.log(pc.green(`    + ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            if (removed.length > 0) {
+                                console.log(pc.yellow(`  ⚠ ${assetType}: ${removed.length} skill(s) no longer in upstream (kept in meta)`));
+                                for (const u of removed) {
+                                    console.log(pc.yellow(`    - ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            hasChanges = true;
+                        }
+                    }
+                    else {
+                        let internalChanged = false;
+                        const refreshedUnits = currentUnits.map((current) => {
+                            const scanned = scannedUnits.find((s) => s.name === current.name);
+                            if (scanned && scanned.isDirectory && current.isDirectory) {
+                                const currentInternal = (current.internalFiles || []).sort().join(',');
+                                const scannedInternal = (scanned.internalFiles || []).sort().join(',');
+                                if (currentInternal !== scannedInternal) {
+                                    internalChanged = true;
+                                    return { ...current, internalFiles: scanned.internalFiles };
+                                }
+                            }
+                            return current;
+                        });
+                        if (internalChanged && !options.dryRun) {
+                            updatedMeta = syncMeta.updatePackageFilesystemMeta(updatedMeta, prefix, assetType, refreshedUnits);
+                            console.log(pc.green(`  ✓ ${assetType}: internal file lists updated`));
+                            hasChanges = true;
+                        }
+                        else if (internalChanged && options.dryRun) {
+                            console.log(pc.gray(`  [DRY RUN] ${assetType}: would update internal file lists`));
+                        }
+                        else {
+                            console.log(pc.gray(`  ${assetType}: no changes`));
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            console.log(pc.yellow(`  ⚠ Could not scan package assets, skipping filesystem update`));
+        }
+        if (options.sync && !options.dryRun) {
+            console.log(pc.cyan(`  Syncing files...`));
+            try {
+                await sync.syncPackage(packageName, {
+                    force: true,
+                    dryRun: false,
+                    local: isLocal,
+                    ref: options.ref,
+                    flat: true,
+                }, cwd, packageInfo.exclusions, destDir);
+                console.log(pc.green(`  ✓ Files synced`));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                console.log(pc.red(`  ✗ Sync failed: ${message}`));
+            }
+        }
+        else if (options.sync && options.dryRun) {
+            console.log(pc.gray(`  [DRY RUN] Would re-sync files`));
+        }
+    }
+    if (hasChanges && !options.dryRun) {
+        updatedMeta.syncedAt = new Date().toISOString();
+        updatedMeta.skillUnitFormat = constants.SCHEMA_VERSIONS.SKILL_UNIT_FORMAT;
+        syncMeta.writeUnifiedSyncMeta(destDir, updatedMeta);
+        console.log(pc.green(`\n✓ Metadata updated`));
+    }
+    else if (options.dryRun) {
+        console.log(pc.gray(`\n[DRY RUN] No changes written`));
+    }
+    else {
+        console.log(pc.gray(`\nNo changes needed`));
+    }
+};
+
+exports.runUpdateCommand = runUpdateCommand;

package/dist/commands/update.d.ts

@@ -0,0 +1,13 @@
+export interface UpdateCommandOptions {
+    package?: string;
+    local?: boolean;
+    ref?: string;
+    dryRun?: boolean;
+    sync?: boolean;
+}
+/**
+ * Run the update command
+ * @param options - Update command options
+ * @param cwd - Current working directory
+ */
+export declare const runUpdateCommand: (options: UpdateCommandOptions, cwd?: string) => Promise<void>;

package/dist/commands/update.mjs

@@ -0,0 +1,176 @@
+import pc from 'picocolors';
+import { scanPackageAssets, buildSkillUnitsFromTree } from '../core/packageScanner.mjs';
+import { syncPackage } from '../core/sync.mjs';
+import { readUnifiedSyncMeta, updatePackageVersion, updatePackageFilesystemMeta, writeUnifiedSyncMeta } from '../core/syncMeta.mjs';
+import { SCHEMA_VERSIONS } from '../core/constants.mjs';
+import { logger } from '../utils/logger.mjs';
+import { findGitRoot, readLocalPackageJson, readPackageJson } from '../utils/package.mjs';
+import { packageNameToPrefix } from '../utils/packageName.mjs';
+
+const runUpdateCommand = async (options, cwd = process.cwd()) => {
+    const destDir = findGitRoot(cwd) ?? cwd;
+    const meta = readUnifiedSyncMeta(destDir);
+    if (!meta || Object.keys(meta.packages).length === 0) {
+        logger.info('No packages synced yet. Use "sync" or "add" first.');
+        return;
+    }
+    const packagesToUpdate = [];
+    if (options.package) {
+        const prefix = packageNameToPrefix(options.package);
+        if (!meta.packages[prefix]) {
+            logger.error(`Package ${options.package} is not synced.`);
+            process.exit(1);
+            return;
+        }
+        packagesToUpdate.push(prefix);
+    }
+    else {
+        packagesToUpdate.push(...Object.keys(meta.packages));
+    }
+    let updatedMeta = { ...meta };
+    let hasChanges = false;
+    for (const prefix of packagesToUpdate) {
+        const packageInfo = updatedMeta.packages[prefix];
+        const packageName = packageInfo.originalName;
+        console.log(pc.cyan(`\nUpdating ${packageName}...`));
+        const isLocal = options.local ?? packageInfo.local ?? false;
+        const currentPkgInfo = isLocal
+            ? readLocalPackageJson(packageName, cwd)
+            : readPackageJson(packageName, cwd);
+        if (!currentPkgInfo) {
+            const location = isLocal ? 'workspace' : 'node_modules';
+            console.log(pc.yellow(`  ⚠ Package not found in ${location}, skipping version update`));
+        }
+        else {
+            const newVersion = currentPkgInfo.version;
+            if (newVersion !== packageInfo.version) {
+                if (options.dryRun) {
+                    console.log(pc.gray(`  [DRY RUN] Would update version: ${packageInfo.version} → ${newVersion}`));
+                }
+                else {
+                    updatedMeta = updatePackageVersion(updatedMeta, prefix, newVersion);
+                    console.log(pc.green(`  ✓ Version updated: ${packageInfo.version} → ${newVersion}`));
+                    hasChanges = true;
+                }
+            }
+            else {
+                console.log(pc.gray(`  Version unchanged: ${packageInfo.version}`));
+            }
+        }
+        try {
+            const scannedTrees = await scanPackageAssets(packageName, {
+                local: isLocal,
+                ref: options.ref,
+                cwd,
+            });
+            if (scannedTrees && scannedTrees.length > 0) {
+                for (const assetTypeTree of scannedTrees) {
+                    const assetType = assetTypeTree.label;
+                    const scannedUnits = buildSkillUnitsFromTree(assetTypeTree, prefix);
+                    const currentUnits = packageInfo.files[assetType] || [];
+                    const scannedNames = new Set(scannedUnits.map((u) => u.name));
+                    const currentNames = new Set(currentUnits.map((u) => u.name));
+                    const added = scannedUnits.filter((u) => !currentNames.has(u.name));
+                    const removed = currentUnits.filter((u) => !scannedNames.has(u.name));
+                    const unchanged = currentUnits.filter((u) => scannedNames.has(u.name));
+                    if (added.length > 0 || removed.length > 0) {
+                        const mergedUnits = [...unchanged, ...added];
+                        if (options.dryRun) {
+                            if (added.length > 0) {
+                                console.log(pc.gray(`  [DRY RUN] ${assetType}: ${added.length} new skill(s) found`));
+                                for (const u of added) {
+                                    console.log(pc.gray(`    + ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            if (removed.length > 0) {
+                                console.log(pc.yellow(`  [DRY RUN] ${assetType}: ${removed.length} skill(s) no longer in upstream`));
+                                for (const u of removed) {
+                                    console.log(pc.yellow(`    - ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                        }
+                        else {
+                            updatedMeta = updatePackageFilesystemMeta(updatedMeta, prefix, assetType, mergedUnits);
+                            if (added.length > 0) {
+                                console.log(pc.green(`  ✓ ${assetType}: ${added.length} new skill(s) added to meta`));
+                                for (const u of added) {
+                                    console.log(pc.green(`    + ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            if (removed.length > 0) {
+                                console.log(pc.yellow(`  ⚠ ${assetType}: ${removed.length} skill(s) no longer in upstream (kept in meta)`));
+                                for (const u of removed) {
+                                    console.log(pc.yellow(`    - ${u.name}${u.isDirectory ? '/' : ''}`));
+                                }
+                            }
+                            hasChanges = true;
+                        }
+                    }
+                    else {
+                        let internalChanged = false;
+                        const refreshedUnits = currentUnits.map((current) => {
+                            const scanned = scannedUnits.find((s) => s.name === current.name);
+                            if (scanned && scanned.isDirectory && current.isDirectory) {
+                                const currentInternal = (current.internalFiles || []).sort().join(',');
+                                const scannedInternal = (scanned.internalFiles || []).sort().join(',');
+                                if (currentInternal !== scannedInternal) {
+                                    internalChanged = true;
+                                    return { ...current, internalFiles: scanned.internalFiles };
+                                }
+                            }
+                            return current;
+                        });
+                        if (internalChanged && !options.dryRun) {
+                            updatedMeta = updatePackageFilesystemMeta(updatedMeta, prefix, assetType, refreshedUnits);
+                            console.log(pc.green(`  ✓ ${assetType}: internal file lists updated`));
+                            hasChanges = true;
+                        }
+                        else if (internalChanged && options.dryRun) {
+                            console.log(pc.gray(`  [DRY RUN] ${assetType}: would update internal file lists`));
+                        }
+                        else {
+                            console.log(pc.gray(`  ${assetType}: no changes`));
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            console.log(pc.yellow(`  ⚠ Could not scan package assets, skipping filesystem update`));
+        }
+        if (options.sync && !options.dryRun) {
+            console.log(pc.cyan(`  Syncing files...`));
+            try {
+                await syncPackage(packageName, {
+                    force: true,
+                    dryRun: false,
+                    local: isLocal,
+                    ref: options.ref,
+                    flat: true,
+                }, cwd, packageInfo.exclusions, destDir);
+                console.log(pc.green(`  ✓ Files synced`));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                console.log(pc.red(`  ✗ Sync failed: ${message}`));
+            }
+        }
+        else if (options.sync && options.dryRun) {
+            console.log(pc.gray(`  [DRY RUN] Would re-sync files`));
+        }
+    }
+    if (hasChanges && !options.dryRun) {
+        updatedMeta.syncedAt = new Date().toISOString();
+        updatedMeta.skillUnitFormat = SCHEMA_VERSIONS.SKILL_UNIT_FORMAT;
+        writeUnifiedSyncMeta(destDir, updatedMeta);
+        console.log(pc.green(`\n✓ Metadata updated`));
+    }
+    else if (options.dryRun) {
+        console.log(pc.gray(`\n[DRY RUN] No changes written`));
+    }
+    else {
+        console.log(pc.gray(`\nNo changes needed`));
+    }
+};
+
+export { runUpdateCommand };

package/dist/components/add/AddCommand.cjs

@@ -70,6 +70,17 @@ const AddCommand = ({ packageName, local, ref, onComplete, onError, onCancel, })
 };
 function extractSelection(nodes, included, excluded) {
     for (const node of nodes) {
+        if (node.disabled)
+            continue;
+        if (node.type === 'skill-directory') {
+            if (node.selected) {
+                included.push(node.path);
+            }
+            else {
+                excluded.push(node.path);
+            }
+            continue;
+        }
         if (node.selected) {
             included.push(node.path);
         }

package/dist/components/add/AddCommand.mjs

@@ -68,6 +68,17 @@ const AddCommand = ({ packageName, local, ref, onComplete, onError, onCancel, })
 };
 function extractSelection(nodes, included, excluded) {
     for (const node of nodes) {
+        if (node.disabled)
+            continue;
+        if (node.type === 'skill-directory') {
+            if (node.selected) {
+                included.push(node.path);
+            }
+            else {
+                excluded.push(node.path);
+            }
+            continue;
+        }
         if (node.selected) {
             included.push(node.path);
         }