@slats/claude-assets-sync 0.0.6 → 0.1.1

package/dist/commands/add.cjs

@@ -3,10 +3,34 @@
 var ink = require('ink');
 var React = require('react');
 var AddCommand = require('../components/add/AddCommand.cjs');
+var BulkAddView = require('../components/add/BulkAddView.cjs');
 var sync = require('../core/sync.cjs');
 
 async function runAddCommand(options, cwd) {
     const workingDir = process.cwd();
+    if (options.pattern) {
+        try {
+            new RegExp(options.pattern);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Invalid regex pattern "${options.pattern}": ${msg}`);
+        }
+        const { waitUntilExit } = ink.render(React.createElement(BulkAddView.BulkAddView, {
+            pattern: options.pattern,
+            cwd: workingDir,
+            local: options.local ?? false,
+            ref: options.ref,
+        }));
+        await waitUntilExit();
+        return;
+    }
+    if (!options.package) {
+        console.error('Error: either --package or --pattern must be provided');
+        console.error('  Usage: claude-assets-sync add -p <name>');
+        console.error('         claude-assets-sync add --pattern <regex>');
+        process.exit(1);
+    }
     return new Promise((resolve, reject) => {
         const { waitUntilExit } = ink.render(React.createElement(AddCommand.AddCommand, {
             packageName: options.package,

package/dist/commands/add.d.ts

@@ -1,10 +1,6 @@
-export interface AddCommandOptions {
-    package: string;
-    local?: boolean;
-    ref?: string;
-}
+import type { AddCommandOptions } from '../commands/types.js';
 /**
- * Run the add command with interactive asset selection
+ * Run the add command with interactive asset selection or bulk pattern mode
  *
  * @param options - Add command options
  * @param cwd - Current working directory

package/dist/commands/add.mjs

@@ -1,10 +1,34 @@
 import { render } from 'ink';
 import React from 'react';
 import { AddCommand } from '../components/add/AddCommand.mjs';
+import { BulkAddView } from '../components/add/BulkAddView.mjs';
 import { syncPackage } from '../core/sync.mjs';
 
 async function runAddCommand(options, cwd) {
     const workingDir = process.cwd();
+    if (options.pattern) {
+        try {
+            new RegExp(options.pattern);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Invalid regex pattern "${options.pattern}": ${msg}`);
+        }
+        const { waitUntilExit } = render(React.createElement(BulkAddView, {
+            pattern: options.pattern,
+            cwd: workingDir,
+            local: options.local ?? false,
+            ref: options.ref,
+        }));
+        await waitUntilExit();
+        return;
+    }
+    if (!options.package) {
+        console.error('Error: either --package or --pattern must be provided');
+        console.error('  Usage: claude-assets-sync add -p <name>');
+        console.error('         claude-assets-sync add --pattern <regex>');
+        process.exit(1);
+    }
     return new Promise((resolve, reject) => {
         const { waitUntilExit } = render(React.createElement(AddCommand, {
             packageName: options.package,

package/dist/commands/index.d.ts

@@ -3,13 +3,12 @@
  */
 export * from './types';
 export { runSyncCommand } from './sync';
-export { runListCommand } from './list';
+export { runListCommand, registerListCommand } from './list';
 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

package/dist/commands/list.cjs

@@ -46,7 +46,8 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (isTTY()) {
-        ink.render(React.createElement(ListCommand.ListCommand, { cwd: destDir }));
+        const { waitUntilExit } = ink.render(React.createElement(ListCommand.ListCommand, { cwd: destDir }));
+        await waitUntilExit();
         return;
     }
     const packages = [];
@@ -79,5 +80,15 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         console.log('');
     }
 };
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await runListCommand({ json: opts.json });
+    });
+}
 
+exports.registerListCommand = registerListCommand;
 exports.runListCommand = runListCommand;

package/dist/commands/list.d.ts

@@ -1,6 +1,15 @@
+/**
+ * List command - list all synced packages
+ */
+import type { Command } from 'commander';
 import type { ListCommandOptions } from './types.js';
 /**
  * Run the list command
  * @param options - List command options
  */
-export declare const runListCommand: (options: ListCommandOptions, cwd?: string) => Promise<void>;
+declare const runListCommand: (options: ListCommandOptions, cwd?: string) => Promise<void>;
+/**
+ * Register the list command with the CLI program
+ */
+export declare function registerListCommand(program: Command): void;
+export { runListCommand };

package/dist/commands/list.mjs

@@ -44,7 +44,8 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (isTTY()) {
-        render(React.createElement(ListCommand, { cwd: destDir }));
+        const { waitUntilExit } = render(React.createElement(ListCommand, { cwd: destDir }));
+        await waitUntilExit();
         return;
     }
     const packages = [];
@@ -77,5 +78,14 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         console.log('');
     }
 };
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await runListCommand({ json: opts.json });
+    });
+}
 
-export { runListCommand };
+export { registerListCommand, runListCommand };

package/dist/commands/remove.cjs

@@ -2,8 +2,10 @@
 
 var fs = require('node:fs');
 var path = require('node:path');
-var readline = require('node:readline/promises');
+var ink = require('ink');
 var pc = require('picocolors');
+var React = require('react');
+var RemoveConfirm = require('../components/remove/RemoveConfirm.cjs');
 var syncMeta = require('../core/syncMeta.cjs');
 var logger = require('../utils/logger.cjs');
 var packageName = require('../utils/packageName.cjs');
@@ -27,8 +29,36 @@ function _interopNamespaceDefault(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 
+function isTTY() {
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+function performRemoval(filesToRemove, meta, prefix, packageName, cwd) {
+    for (const { path: filePath } of filesToRemove) {
+        try {
+            const stat = fs__namespace.statSync(filePath);
+            if (stat.isDirectory()) {
+                fs__namespace.rmSync(filePath, { recursive: true, force: true });
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+            else {
+                fs__namespace.unlinkSync(filePath);
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.logger.error(`Failed to remove ${filePath}: ${error}`);
+            }
+        }
+    }
+    if (meta) {
+        delete meta.packages[prefix];
+        meta.syncedAt = new Date().toISOString();
+        syncMeta.writeUnifiedSyncMeta(cwd, meta);
+    }
+    logger.logger.success(`\nRemoved package ${packageName}`);
+}
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName$1, yes, dryRun } = options;
     const prefix = packageName.packageNameToPrefix(packageName$1);
@@ -71,39 +101,27 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (!yes) {
-        const rl = readline__namespace.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const answer = await rl.question(pc.yellow('Remove these files? (y/N): '));
-        rl.close();
-        if (answer.toLowerCase() !== 'y') {
-            logger.logger.info('Cancelled.');
-            return;
-        }
-    }
-    for (const { path: filePath } of filesToRemove) {
-        try {
-            const stat = fs__namespace.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs__namespace.rmSync(filePath, { recursive: true, force: true });
-                console.log(`${pc.red('-')} ${filePath}`);
-            }
-            else {
-                fs__namespace.unlinkSync(filePath);
-                console.log(`${pc.red('-')} ${filePath}`);
+        if (isTTY()) {
+            let confirmed = false;
+            const { waitUntilExit } = ink.render(React.createElement(RemoveConfirm.RemoveConfirm, {
+                packageName: packageName$1,
+                filesToRemove,
+                onConfirm: (result) => {
+                    confirmed = result;
+                },
+            }));
+            await waitUntilExit();
+            if (!confirmed) {
+                logger.logger.info('Cancelled.');
+                return;
             }
         }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.logger.error(`Failed to remove ${filePath}: ${error}`);
-            }
+        else {
+            logger.logger.info('Cancelled (non-interactive terminal).');
+            return;
         }
     }
-    delete meta.packages[prefix];
-    meta.syncedAt = new Date().toISOString();
-    syncMeta.writeUnifiedSyncMeta(cwd, meta);
-    logger.logger.success(`\nRemoved package ${packageName$1}`);
+    performRemoval(filesToRemove, meta, prefix, packageName$1, cwd);
 };
 
 exports.runRemoveCommand = runRemoveCommand;

package/dist/commands/remove.mjs

@@ -1,11 +1,42 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as readline from 'node:readline/promises';
+import { render } from 'ink';
 import pc from 'picocolors';
+import React from 'react';
+import { RemoveConfirm } from '../components/remove/RemoveConfirm.mjs';
 import { readUnifiedSyncMeta, writeUnifiedSyncMeta } from '../core/syncMeta.mjs';
 import { logger } from '../utils/logger.mjs';
 import { packageNameToPrefix } from '../utils/packageName.mjs';
 
+function isTTY() {
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+function performRemoval(filesToRemove, meta, prefix, packageName, cwd) {
+    for (const { path: filePath } of filesToRemove) {
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                fs.rmSync(filePath, { recursive: true, force: true });
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+            else {
+                fs.unlinkSync(filePath);
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.error(`Failed to remove ${filePath}: ${error}`);
+            }
+        }
+    }
+    if (meta) {
+        delete meta.packages[prefix];
+        meta.syncedAt = new Date().toISOString();
+        writeUnifiedSyncMeta(cwd, meta);
+    }
+    logger.success(`\nRemoved package ${packageName}`);
+}
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName, yes, dryRun } = options;
     const prefix = packageNameToPrefix(packageName);
@@ -48,39 +79,27 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (!yes) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const answer = await rl.question(pc.yellow('Remove these files? (y/N): '));
-        rl.close();
-        if (answer.toLowerCase() !== 'y') {
-            logger.info('Cancelled.');
-            return;
-        }
-    }
-    for (const { path: filePath } of filesToRemove) {
-        try {
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs.rmSync(filePath, { recursive: true, force: true });
-                console.log(`${pc.red('-')} ${filePath}`);
-            }
-            else {
-                fs.unlinkSync(filePath);
-                console.log(`${pc.red('-')} ${filePath}`);
+        if (isTTY()) {
+            let confirmed = false;
+            const { waitUntilExit } = render(React.createElement(RemoveConfirm, {
+                packageName,
+                filesToRemove,
+                onConfirm: (result) => {
+                    confirmed = result;
+                },
+            }));
+            await waitUntilExit();
+            if (!confirmed) {
+                logger.info('Cancelled.');
+                return;
             }
         }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.error(`Failed to remove ${filePath}: ${error}`);
-            }
+        else {
+            logger.info('Cancelled (non-interactive terminal).');
+            return;
         }
     }
-    delete meta.packages[prefix];
-    meta.syncedAt = new Date().toISOString();
-    writeUnifiedSyncMeta(cwd, meta);
-    logger.success(`\nRemoved package ${packageName}`);
+    performRemoval(filesToRemove, meta, prefix, packageName, cwd);
 };
 
 export { runRemoveCommand };

package/dist/commands/types.d.ts

@@ -9,6 +9,15 @@ export interface CommandResult {
     success: boolean;
     message?: string;
 }
+/**
+ * Options for add command
+ */
+export interface AddCommandOptions {
+    package?: string;
+    pattern?: string;
+    local?: boolean;
+    ref?: string;
+}
 /**
  * Options for sync command
  */

package/dist/commands/update.cjs

@@ -1,14 +1,40 @@
 'use strict';
 
 var pc = require('picocolors');
+var constants = require('../core/constants.cjs');
 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');
 
+async function updatePackageVersionAndSync(prefix, meta, options, cwd) {
+    const packageInfo = meta.packages[prefix];
+    if (!packageInfo) {
+        throw new Error(`Package ${prefix} not found in metadata`);
+    }
+    const packageName = packageInfo.originalName;
+    const isLocal = options.local ?? packageInfo.local ?? false;
+    const currentPkgInfo = isLocal
+        ? _package.readLocalPackageJson(packageName, cwd)
+        : _package.readPackageJson(packageName, cwd);
+    if (!currentPkgInfo) {
+        return { updatedMeta: meta, versionChanged: false };
+    }
+    const newVersion = currentPkgInfo.version;
+    const oldVersion = packageInfo.version;
+    if (newVersion === oldVersion) {
+        return { updatedMeta: meta, versionChanged: false, oldVersion, newVersion };
+    }
+    let updatedMeta = syncMeta.updatePackageVersion(meta, prefix, newVersion);
+    updatedMeta.syncedAt = new Date().toISOString();
+    {
+        const destDir = _package.findGitRoot(cwd) ?? cwd;
+        await sync.syncPackage(packageName, { force: true, dryRun: false, local: isLocal, ref: options.ref, flat: true }, cwd, packageInfo.exclusions, destDir);
+    }
+    return { updatedMeta, versionChanged: true, oldVersion, newVersion };
+}
 const runUpdateCommand = async (options, cwd = process.cwd()) => {
     const destDir = _package.findGitRoot(cwd) ?? cwd;
     const meta = syncMeta.readUnifiedSyncMeta(destDir);
@@ -113,8 +139,12 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
                         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(',');
+                                const currentInternal = (current.internalFiles || [])
+                                    .sort()
+                                    .join(',');
+                                const scannedInternal = (scanned.internalFiles || [])
+                                    .sort()
+                                    .join(',');
                                 if (currentInternal !== scannedInternal) {
                                     internalChanged = true;
                                     return { ...current, internalFiles: scanned.internalFiles };
@@ -176,3 +206,4 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
 };
 
 exports.runUpdateCommand = runUpdateCommand;
+exports.updatePackageVersionAndSync = updatePackageVersionAndSync;

package/dist/commands/update.d.ts

@@ -1,3 +1,4 @@
+import type { UnifiedSyncMeta } from '../utils/types';
 export interface UpdateCommandOptions {
     package?: string;
     local?: boolean;
@@ -5,6 +6,21 @@ export interface UpdateCommandOptions {
     dryRun?: boolean;
     sync?: boolean;
 }
+export interface UpdatePackageResult {
+    updatedMeta: UnifiedSyncMeta;
+    versionChanged: boolean;
+    oldVersion?: string;
+    newVersion?: string;
+}
+/**
+ * Higher-level orchestration: read installed version, compare with meta, update if different,
+ * optionally re-sync files. Can be called from both CLI and interactive list UI.
+ */
+export declare function updatePackageVersionAndSync(prefix: string, meta: UnifiedSyncMeta, options: {
+    local?: boolean;
+    ref?: string;
+    sync?: boolean;
+}, cwd: string): Promise<UpdatePackageResult>;
 /**
  * Run the update command
  * @param options - Update command options

package/dist/commands/update.mjs

@@ -1,12 +1,38 @@
 import pc from 'picocolors';
+import { SCHEMA_VERSIONS } from '../core/constants.mjs';
 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';
 
+async function updatePackageVersionAndSync(prefix, meta, options, cwd) {
+    const packageInfo = meta.packages[prefix];
+    if (!packageInfo) {
+        throw new Error(`Package ${prefix} not found in metadata`);
+    }
+    const packageName = packageInfo.originalName;
+    const isLocal = options.local ?? packageInfo.local ?? false;
+    const currentPkgInfo = isLocal
+        ? readLocalPackageJson(packageName, cwd)
+        : readPackageJson(packageName, cwd);
+    if (!currentPkgInfo) {
+        return { updatedMeta: meta, versionChanged: false };
+    }
+    const newVersion = currentPkgInfo.version;
+    const oldVersion = packageInfo.version;
+    if (newVersion === oldVersion) {
+        return { updatedMeta: meta, versionChanged: false, oldVersion, newVersion };
+    }
+    let updatedMeta = updatePackageVersion(meta, prefix, newVersion);
+    updatedMeta.syncedAt = new Date().toISOString();
+    {
+        const destDir = findGitRoot(cwd) ?? cwd;
+        await syncPackage(packageName, { force: true, dryRun: false, local: isLocal, ref: options.ref, flat: true }, cwd, packageInfo.exclusions, destDir);
+    }
+    return { updatedMeta, versionChanged: true, oldVersion, newVersion };
+}
 const runUpdateCommand = async (options, cwd = process.cwd()) => {
     const destDir = findGitRoot(cwd) ?? cwd;
     const meta = readUnifiedSyncMeta(destDir);
@@ -111,8 +137,12 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
                         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(',');
+                                const currentInternal = (current.internalFiles || [])
+                                    .sort()
+                                    .join(',');
+                                const scannedInternal = (scanned.internalFiles || [])
+                                    .sort()
+                                    .join(',');
                                 if (currentInternal !== scannedInternal) {
                                     internalChanged = true;
                                     return { ...current, internalFiles: scanned.internalFiles };
@@ -173,4 +203,4 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
     }
 };
 
-export { runUpdateCommand };
+export { runUpdateCommand, updatePackageVersionAndSync };