@slats/claude-assets-sync 0.0.1 → 0.0.3

package/dist/components/add/AddCommand.mjs

@@ -0,0 +1,90 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useHandle } from '@winglet/react-utils/hook';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useState, useEffect, useCallback } from 'react';
+import { scanPackageAssets } from '../../core/packageScanner.mjs';
+import { TreeSelect } from '../tree/TreeSelect.mjs';
+
+const AddCommand = ({ packageName, local, ref, onComplete, onError, onCancel, }) => {
+    const [state, setState] = useState('scanning');
+    const [trees, setTrees] = useState([]);
+    const [error, setError] = useState(null);
+    const handleComplete = useHandle(onComplete);
+    const handleError = useHandle(onError);
+    const handleCancel = useHandle(onCancel);
+    useEffect(() => {
+        const scan = async () => {
+            try {
+                setState('scanning');
+                const scanned = await scanPackageAssets(packageName, { local, ref });
+                setTrees(scanned);
+                setState('selecting');
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                setError(error);
+                setState('error');
+                handleError(error);
+            }
+        };
+        scan();
+    }, [packageName, local, ref, handleError]);
+    const handleSubmit = useCallback((selectedTrees) => {
+        setState('confirming');
+        const includedAssets = {};
+        const excludedAssets = {};
+        for (const tree of selectedTrees) {
+            const assetType = tree.label;
+            includedAssets[assetType] = [];
+            excludedAssets[assetType] = [];
+            if (tree.children) {
+                extractSelection(tree.children, includedAssets[assetType], excludedAssets[assetType]);
+            }
+        }
+        const selection = {
+            packageName,
+            source: local ? 'local' : 'npm',
+            ref,
+            includedAssets,
+            excludedAssets,
+        };
+        setState('done');
+        handleComplete(selection);
+    }, [packageName, local, ref, handleComplete]);
+    if (state === 'scanning') {
+        return (jsx(Box, { children: jsxs(Text, { color: "cyan", children: [jsx(Spinner, { type: "dots" }), " Scanning package assets..."] }) }));
+    }
+    if (state === 'error') {
+        return (jsx(Box, { flexDirection: "column", children: jsxs(Text, { color: "red", children: ["Error: ", error?.message] }) }));
+    }
+    if (state === 'selecting') {
+        return (jsxs(Box, { flexDirection: "column", children: [jsx(Box, { marginBottom: 1, children: jsxs(Text, { bold: true, children: ["Select assets to sync from ", packageName] }) }), jsx(Box, { marginBottom: 1, children: jsx(Text, { dimColor: true, children: "Use \u2191/\u2193 to navigate, Space to toggle, \u2192/\u2190 to expand/collapse, Enter to confirm, Esc to cancel" }) }), jsx(TreeSelect, { trees: trees, onSubmit: handleSubmit, onCancel: handleCancel })] }));
+    }
+    if (state === 'confirming' || state === 'done') {
+        return (jsx(Box, { children: jsx(Text, { color: "green", children: "\u2713 Selection confirmed" }) }));
+    }
+    return null;
+};
+function extractSelection(nodes, included, excluded) {
+    for (const node of nodes) {
+        if (node.selected) {
+            included.push(node.path);
+        }
+        else {
+            excluded.push(node.path);
+        }
+        if (node.children && hasPartialSelection(node)) {
+            extractSelection(node.children, included, excluded);
+        }
+    }
+}
+function hasPartialSelection(node) {
+    if (!node.children || node.children.length === 0) {
+        return false;
+    }
+    const selectedCount = node.children.filter((c) => c.selected).length;
+    return selectedCount > 0 && selectedCount < node.children.length;
+}
+
+export { AddCommand };

package/dist/components/add/index.d.ts

@@ -0,0 +1,2 @@
+export { AddCommand } from './AddCommand.js';
+export type { AddCommandProps } from './AddCommand.js';

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './primitives/index.js';
+export * from './status/index.js';

package/dist/components/list/EditableTreeItem.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface EditableTreeItemProps {
+    label: string;
+    depth: number;
+    selected: boolean;
+    markedForDeletion?: boolean;
+    markedForAddition?: boolean;
+    onToggleDelete?: () => void;
+}
+/**
+ * Editable tree item component for list view
+ */
+export declare const EditableTreeItem: React.FC<EditableTreeItemProps>;

package/dist/components/list/ListCommand.cjs

@@ -0,0 +1,440 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var fs = require('node:fs');
+var path = require('node:path');
+var ink = require('ink');
+var Spinner = require('ink-spinner');
+var React = require('react');
+var packageScanner = require('../../core/packageScanner.cjs');
+var sync = require('../../core/sync.cjs');
+var syncMeta = require('../../core/syncMeta.cjs');
+var TreeSelect = require('../tree/TreeSelect.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);
+
+const ListCommand = ({ cwd }) => {
+    const [state, setState] = React.useState('loading');
+    const [packageFiles, setPackageFiles] = React.useState({});
+    const [meta, setMeta] = React.useState(null);
+    const [lastRefresh, setLastRefresh] = React.useState(Date.now());
+    const [changesSummary, setChangesSummary] = React.useState(null);
+    const hasLoadedRef = React.useRef(false);
+    const buildTrees = () => {
+        if (!meta)
+            return [];
+        const trees = [];
+        for (const [prefix, packageInfo] of Object.entries(meta.packages)) {
+            const packageData = packageFiles[prefix];
+            if (!packageData)
+                continue;
+            const assetTypeTrees = packageData.available.map((assetTypeTree) => {
+                const clonedTree = { ...assetTypeTree };
+                if (clonedTree.children) {
+                    clonedTree.children = clonedTree.children.map((fileNode) => {
+                        const filePath = `${assetTypeTree.label}/${fileNode.label}`;
+                        return {
+                            ...fileNode,
+                            selected: packageData.selected.has(filePath),
+                        };
+                    });
+                    const anySelected = clonedTree.children.some((f) => f.selected);
+                    clonedTree.selected = anySelected;
+                }
+                return clonedTree;
+            });
+            trees.push({
+                id: prefix,
+                label: `${packageInfo.originalName}@${packageInfo.version}`,
+                path: packageInfo.originalName,
+                type: 'directory',
+                children: assetTypeTrees,
+                selected: true,
+                expanded: true,
+            });
+        }
+        return trees;
+    };
+    const loadSyncedFiles = React.useCallback(async (isRefresh = false) => {
+        const loadedMeta = syncMeta.readUnifiedSyncMeta(cwd);
+        if (!loadedMeta || Object.keys(loadedMeta.packages).length === 0) {
+            setState('done');
+            return;
+        }
+        if (!isRefresh) {
+            setMeta(loadedMeta);
+        }
+        const currentSelected = {};
+        setPackageFiles((prev) => {
+            for (const [prefix, data] of Object.entries(prev)) {
+                currentSelected[prefix] = data.selected;
+            }
+            return prev;
+        });
+        const fetchPromises = Object.entries(loadedMeta.packages).map(async ([prefix, packageInfo]) => {
+            try {
+                const isLocal = packageInfo.local ?? true;
+                let scannedTrees = await packageScanner.scanPackageAssets(packageInfo.originalName, {
+                    local: isLocal,
+                    ref: undefined,
+                }).catch(() => null);
+                if (!scannedTrees && packageInfo.local === undefined) {
+                    scannedTrees = await packageScanner.scanPackageAssets(packageInfo.originalName, {
+                        local: !isLocal,
+                        ref: undefined,
+                    }).catch(() => null);
+                }
+                if (scannedTrees) {
+                    return { prefix, available: scannedTrees, packageInfo };
+                }
+                else {
+                    throw new Error('Scan failed, using synced files only');
+                }
+            }
+            catch {
+                const assetTypeTrees = [];
+                for (const [assetType, files] of Object.entries(packageInfo.files)) {
+                    const fileArray = Array.isArray(files) ? files : [];
+                    if (fileArray.length === 0)
+                        continue;
+                    const fileNodes = fileArray.map((file) => {
+                        const fileName = typeof file === 'string' ? file : file.transformed;
+                        return {
+                            id: `${prefix}/${assetType}/${fileName}`,
+                            label: fileName,
+                            path: `${assetType}/${fileName}`,
+                            type: 'file',
+                            selected: true,
+                            expanded: false,
+                        };
+                    });
+                    assetTypeTrees.push({
+                        id: `${prefix}/${assetType}`,
+                        label: assetType,
+                        path: assetType,
+                        type: 'directory',
+                        children: fileNodes,
+                        selected: true,
+                        expanded: true,
+                    });
+                }
+                return { prefix, available: assetTypeTrees, packageInfo };
+            }
+        });
+        const results = await Promise.all(fetchPromises);
+        const newPackageFiles = {};
+        for (const { prefix, available, packageInfo } of results) {
+            const excludedFiles = new Set(packageInfo.exclusions?.files || []);
+            const metaSelectedFiles = new Set(Object.entries(packageInfo.files).flatMap(([assetType, files]) => (Array.isArray(files) ? files : [])
+                .map((f) => {
+                const fileName = typeof f === 'string' ? f : f.original;
+                const filePath = `${assetType}/${fileName}`;
+                if (excludedFiles.has(filePath) ||
+                    excludedFiles.has(fileName)) {
+                    return null;
+                }
+                return filePath;
+            })
+                .filter((f) => f !== null)));
+            const selectedFiles = isRefresh && currentSelected[prefix]
+                ? currentSelected[prefix]
+                : metaSelectedFiles;
+            newPackageFiles[prefix] = {
+                available,
+                selected: selectedFiles,
+            };
+        }
+        setPackageFiles(newPackageFiles);
+        setState('selecting');
+    }, [cwd]);
+    React.useEffect(() => {
+        if (!hasLoadedRef.current) {
+            hasLoadedRef.current = true;
+            loadSyncedFiles().catch((error) => {
+                console.error('Failed to load synced files:', error);
+                setState('done');
+            });
+        }
+    }, [loadSyncedFiles]);
+    const handleRefresh = () => {
+        if (state !== 'selecting')
+            return;
+        const now = Date.now();
+        if (now - lastRefresh < 30000) {
+            return;
+        }
+        setLastRefresh(now);
+        setState('loading');
+        setTimeout(() => {
+            loadSyncedFiles(true).catch((error) => {
+                console.error('Failed to refresh:', error);
+                setState('selecting');
+            });
+        }, 100);
+    };
+    ink.useInput((input) => {
+        if (state === 'confirming') {
+            if (input === 'y' || input === 'Y') {
+                handleConfirm();
+            }
+            else if (input === 'n' || input === 'N') {
+                handleCancelConfirm();
+            }
+        }
+    });
+    const handleSubmit = async (selectedTrees) => {
+        if (!meta) {
+            setState('done');
+            process.exit(0);
+            return;
+        }
+        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.selected) {
+                                selectedPaths.add(`${assetTypeNode.label}/${fileNode.label}`);
+                            }
+                        }
+                    }
+                }
+            }
+            newPackageFiles[prefix] = {
+                ...newPackageFiles[prefix],
+                selected: selectedPaths,
+            };
+        }
+        setPackageFiles(newPackageFiles);
+        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 firstFile = files[0];
+                    const isFlat = typeof firstFile === 'object' && 'transformed' in firstFile;
+                    for (const file of files) {
+                        const fileName = typeof file === 'string' ? file : file.original;
+                        fileOperations.push({
+                            type: 'remove',
+                            prefix,
+                            assetType,
+                            fileName,
+                        });
+                    }
+                    if (isFlat) {
+                        for (const file of files) {
+                            const filePath = path__namespace.join(cwd, '.claude', assetType, file.transformed);
+                            filesToDelete.push(filePath);
+                        }
+                    }
+                    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 fileArray = Array.isArray(originalFiles) ? originalFiles : [];
+                const firstFile = fileArray[0];
+                const isFlat = typeof firstFile === 'object' && 'transformed' in firstFile;
+                if (!selectedFiles || selectedFiles.size === 0) {
+                    hasChanges = true;
+                    for (const file of fileArray) {
+                        const fileName = typeof file === 'string' ? file : file.original;
+                        fileOperations.push({
+                            type: 'remove',
+                            prefix,
+                            assetType,
+                            fileName,
+                        });
+                    }
+                    if (isFlat) {
+                        for (const file of fileArray) {
+                            const filePath = path__namespace.join(cwd, '.claude', assetType, file.transformed);
+                            filesToDelete.push(filePath);
+                        }
+                    }
+                    else {
+                        const dirPath = path__namespace.join(cwd, '.claude', assetType, packageInfo.originalName);
+                        filesToDelete.push(dirPath);
+                    }
+                    continue;
+                }
+                const originalFileNames = new Set(fileArray.map((f) => (typeof f === 'string' ? f : f.transformed)));
+                for (const file of fileArray) {
+                    const fileName = typeof file === 'string' ? file : file.original;
+                    if (!selectedFiles.has(fileName)) {
+                        hasChanges = true;
+                        fileOperations.push({
+                            type: 'remove',
+                            prefix,
+                            assetType,
+                            fileName,
+                        });
+                        if (isFlat) {
+                            const filePath = path__namespace.join(cwd, '.claude', assetType, file.transformed);
+                            filesToDelete.push(filePath);
+                        }
+                        else {
+                            const filePath = path__namespace.join(cwd, '.claude', assetType, packageInfo.originalName, fileName);
+                            filesToDelete.push(filePath);
+                        }
+                    }
+                }
+                for (const fileName of selectedFiles) {
+                    if (!originalFileNames.has(fileName)) {
+                        hasChanges = true;
+                        fileOperations.push({
+                            type: 'add',
+                            prefix,
+                            assetType,
+                            fileName,
+                        });
+                    }
+                }
+            }
+            if (hasChanges) {
+                packagesToSync.push({
+                    prefix,
+                    name: packageInfo.originalName,
+                    local: packageInfo.local,
+                });
+            }
+        }
+        setChangesSummary({ filesToDelete, fileOperations, packagesToSync });
+        setState('confirming');
+    };
+    const handleConfirm = async () => {
+        if (!changesSummary || !meta)
+            return;
+        setState('saving');
+        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.removeFileFromPackage(updatedMeta, op.prefix, op.assetType, op.fileName);
+            }
+        }
+        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) {
+            setState('syncing');
+            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.fileName}`);
+                    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) {
+                    console.error(`Failed to sync ${name}: ${error}`);
+                }
+            }
+        }
+        setState('done');
+        setTimeout(() => process.exit(0), 500);
+    };
+    const handleCancelConfirm = () => {
+        setChangesSummary(null);
+        setState('selecting');
+    };
+    const handleCancel = () => {
+        setState('done');
+        process.exit(0);
+    };
+    if (state === 'loading') {
+        return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsxs(ink.Text, { color: "cyan", children: [jsxRuntime.jsx(Spinner, { type: "dots" }), " Loading synced packages..."] }) }));
+    }
+    if (state === 'confirming' && changesSummary) {
+        return (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsx(ink.Text, { bold: true, children: "Changes to be applied:" }) }), changesSummary.filesToDelete.length > 0 && (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", marginBottom: 1, children: [jsxRuntime.jsxs(ink.Text, { color: "red", bold: true, children: ["Files to delete (", changesSummary.filesToDelete.length, "):"] }), changesSummary.filesToDelete.slice(0, 10).map((filePath) => (jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: jsxRuntime.jsxs(ink.Text, { color: "red", children: ["- ", filePath.replace(cwd, '.')] }) }, filePath))), changesSummary.filesToDelete.length > 10 && (jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: jsxRuntime.jsxs(ink.Text, { dimColor: true, children: ["... and ", changesSummary.filesToDelete.length - 10, " more"] }) }))] })), changesSummary.packagesToSync.length > 0 && (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", marginBottom: 1, children: [jsxRuntime.jsxs(ink.Text, { color: "green", bold: true, children: ["Packages to sync (", changesSummary.packagesToSync.length, "):"] }), changesSummary.packagesToSync.map(({ name }) => (jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: jsxRuntime.jsxs(ink.Text, { color: "green", children: ["+ ", name] }) }, name)))] })), changesSummary.filesToDelete.length === 0 &&
+                    changesSummary.packagesToSync.length === 0 && (jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsx(ink.Text, { dimColor: true, children: "No changes to apply" }) })), jsxRuntime.jsx(ink.Box, { marginTop: 1, children: jsxRuntime.jsx(ink.Text, { bold: true, children: "Apply changes and sync? (y/n): " }) })] }));
+    }
+    if (state === 'saving') {
+        return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsxs(ink.Text, { color: "green", children: [jsxRuntime.jsx(Spinner, { type: "dots" }), " Saving changes..."] }) }));
+    }
+    if (state === 'syncing') {
+        return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsxs(ink.Text, { color: "cyan", children: [jsxRuntime.jsx(Spinner, { type: "dots" }), " Syncing packages..."] }) }));
+    }
+    if (state === 'done' &&
+        (!meta || Object.keys(meta?.packages || {}).length === 0)) {
+        return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsx(ink.Text, { color: "yellow", children: "No packages synced yet." }) }));
+    }
+    if (state === 'selecting') {
+        const trees = buildTrees();
+        return (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsx(ink.Text, { bold: true, children: "Edit synced packages" }) }), jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsx(ink.Text, { dimColor: true, children: "\u2191/\u2193: navigate \u2022 Space: toggle \u2022 \u2192/\u2190: expand/collapse \u2022 r: refresh (30s cooldown) \u2022 Enter: save \u2022 Esc: cancel" }) }), jsxRuntime.jsx(TreeSelect.TreeSelect, { trees: trees, onSubmit: handleSubmit, onCancel: handleCancel, onRefresh: handleRefresh })] }));
+    }
+    return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsx(ink.Text, { color: "green", children: "\u2713 Changes saved" }) }));
+};
+
+exports.ListCommand = ListCommand;

package/dist/components/list/ListCommand.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface ListCommandProps {
+    cwd: string;
+}
+/**
+ * List command component - interactive tree-based editing of synced files
+ */
+export declare const ListCommand: React.FC<ListCommandProps>;