@slats/claude-assets-sync 0.0.1 → 0.0.3

package/dist/components/tree/AssetTreeNode.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var ink = require('ink');
+
+function hasPartialSelection(node) {
+    if (!node.children || node.children.length === 0) {
+        return false;
+    }
+    const selectedCount = node.children.filter((child) => child.selected).length;
+    return selectedCount > 0 && selectedCount < node.children.length;
+}
+const AssetTreeNode = ({ node, depth, isSelected, }) => {
+    const indent = '  '.repeat(depth);
+    let selectionIcon;
+    let iconColor;
+    if (hasPartialSelection(node)) {
+        selectionIcon = '◐';
+        iconColor = 'yellow';
+    }
+    else if (node.selected) {
+        selectionIcon = '●';
+        iconColor = 'green';
+    }
+    else {
+        selectionIcon = '○';
+        iconColor = 'red';
+    }
+    const expandIcon = node.type === 'directory' && node.children
+        ? node.expanded
+            ? '▼'
+            : '▶'
+        : ' ';
+    return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsxs(ink.Text, { color: isSelected ? 'cyan' : undefined, children: [indent, expandIcon, " ", jsxRuntime.jsx(ink.Text, { color: iconColor, children: selectionIcon }), " ", node.label] }) }));
+};
+
+exports.AssetTreeNode = AssetTreeNode;

package/dist/components/tree/AssetTreeNode.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { TreeNode } from '../../utils/types.js';
+export interface AssetTreeNodeProps {
+    node: TreeNode;
+    depth: number;
+    isSelected: boolean;
+    onToggle: () => void;
+}
+/**
+ * Single tree node component for asset selection
+ */
+export declare const AssetTreeNode: React.FC<AssetTreeNodeProps>;

package/dist/components/tree/AssetTreeNode.mjs

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+
+function hasPartialSelection(node) {
+    if (!node.children || node.children.length === 0) {
+        return false;
+    }
+    const selectedCount = node.children.filter((child) => child.selected).length;
+    return selectedCount > 0 && selectedCount < node.children.length;
+}
+const AssetTreeNode = ({ node, depth, isSelected, }) => {
+    const indent = '  '.repeat(depth);
+    let selectionIcon;
+    let iconColor;
+    if (hasPartialSelection(node)) {
+        selectionIcon = '◐';
+        iconColor = 'yellow';
+    }
+    else if (node.selected) {
+        selectionIcon = '●';
+        iconColor = 'green';
+    }
+    else {
+        selectionIcon = '○';
+        iconColor = 'red';
+    }
+    const expandIcon = node.type === 'directory' && node.children
+        ? node.expanded
+            ? '▼'
+            : '▶'
+        : ' ';
+    return (jsx(Box, { children: jsxs(Text, { color: isSelected ? 'cyan' : undefined, children: [indent, expandIcon, " ", jsx(Text, { color: iconColor, children: selectionIcon }), " ", node.label] }) }));
+};
+
+export { AssetTreeNode };

package/dist/components/tree/TreeSelect.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var ink = require('ink');
+var React = require('react');
+var AssetTreeNode = require('./AssetTreeNode.cjs');
+
+const TreeSelect = ({ trees, onSubmit, onCancel, onRefresh, }) => {
+    const [selectedIndex, setSelectedIndex] = React.useState(0);
+    const [treeData, setTreeData] = React.useState(trees);
+    const flattenTree = (nodes, depth = 0) => {
+        const result = [];
+        const traverse = (items, currentDepth, parentPath = []) => {
+            items.forEach((item, index) => {
+                const currentPath = [...parentPath, index];
+                result.push({ node: item, depth: currentDepth, path: currentPath });
+                if (item.expanded && item.children) {
+                    traverse(item.children, currentDepth + 1, currentPath);
+                }
+            });
+        };
+        traverse(nodes, depth);
+        return result;
+    };
+    const flatItems = flattenTree(treeData);
+    ink.useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(flatItems.length - 1, prev + 1));
+        }
+        else if (key.rightArrow) {
+            const current = flatItems[selectedIndex];
+            if (current.node.type === 'directory' && !current.node.expanded) {
+                const newTrees = updateNodeAtPath(treeData, current.path, (node) => ({
+                    ...node,
+                    expanded: true,
+                }));
+                setTreeData(newTrees);
+            }
+        }
+        else if (key.leftArrow) {
+            const current = flatItems[selectedIndex];
+            if (current.node.type === 'directory' && current.node.expanded) {
+                const newTrees = updateNodeAtPath(treeData, current.path, (node) => ({
+                    ...node,
+                    expanded: false,
+                }));
+                setTreeData(newTrees);
+            }
+        }
+        else if (input === ' ') {
+            const current = flatItems[selectedIndex];
+            const newTrees = toggleNodeSelection(treeData, current.path);
+            setTreeData(newTrees);
+        }
+        else if (input === 'r' && onRefresh) {
+            onRefresh();
+        }
+        else if (key.return) {
+            onSubmit(treeData);
+        }
+        else if (key.escape || input === 'q') {
+            onCancel();
+        }
+    });
+    return (jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: flatItems.map((item, index) => (jsxRuntime.jsx(AssetTreeNode.AssetTreeNode, { node: item.node, depth: item.depth, isSelected: index === selectedIndex, onToggle: () => {
+                const newTrees = toggleNodeSelection(treeData, item.path);
+                setTreeData(newTrees);
+            } }, item.path.join('-')))) }));
+};
+function updateNodeAtPath(trees, path, updater) {
+    if (path.length === 0)
+        return trees;
+    const [index, ...rest] = path;
+    const newTrees = [...trees];
+    if (rest.length === 0) {
+        newTrees[index] = updater(newTrees[index]);
+    }
+    else if (newTrees[index].children) {
+        newTrees[index] = {
+            ...newTrees[index],
+            children: updateNodeAtPath(newTrees[index].children, rest, updater),
+        };
+    }
+    return newTrees;
+}
+function toggleNodeSelection(trees, path) {
+    const updatedTrees = updateNodeAtPath(trees, path, (node) => {
+        const newSelected = !node.selected;
+        return toggleNodeAndChildren(node, newSelected);
+    });
+    return updateAncestors(updatedTrees, path);
+}
+function toggleNodeAndChildren(node, selected) {
+    const newNode = { ...node, selected };
+    if (node.children) {
+        newNode.children = node.children.map((child) => toggleNodeAndChildren(child, selected));
+    }
+    return newNode;
+}
+function updateAncestors(trees, path) {
+    if (path.length <= 1) {
+        return trees;
+    }
+    const parentPath = path.slice(0, -1);
+    const updatedTrees = updateNodeAtPath(trees, parentPath, (parentNode) => {
+        if (!parentNode.children || parentNode.children.length === 0) {
+            return parentNode;
+        }
+        const anySelected = parentNode.children.some((child) => child.selected);
+        return {
+            ...parentNode,
+            selected: anySelected,
+        };
+    });
+    return updateAncestors(updatedTrees, parentPath);
+}
+
+exports.TreeSelect = TreeSelect;

package/dist/components/tree/TreeSelect.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { TreeNode } from '../../utils/types.js';
+export interface TreeSelectProps {
+    trees: TreeNode[];
+    onSubmit: (trees: TreeNode[]) => void;
+    onCancel: () => void;
+    onRefresh?: () => void;
+}
+/**
+ * Interactive tree selection component
+ */
+export declare const TreeSelect: React.FC<TreeSelectProps>;

package/dist/components/tree/TreeSelect.mjs

@@ -0,0 +1,119 @@
+import { jsx } from 'react/jsx-runtime';
+import { useInput, Box } from 'ink';
+import { useState } from 'react';
+import { AssetTreeNode } from './AssetTreeNode.mjs';
+
+const TreeSelect = ({ trees, onSubmit, onCancel, onRefresh, }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [treeData, setTreeData] = useState(trees);
+    const flattenTree = (nodes, depth = 0) => {
+        const result = [];
+        const traverse = (items, currentDepth, parentPath = []) => {
+            items.forEach((item, index) => {
+                const currentPath = [...parentPath, index];
+                result.push({ node: item, depth: currentDepth, path: currentPath });
+                if (item.expanded && item.children) {
+                    traverse(item.children, currentDepth + 1, currentPath);
+                }
+            });
+        };
+        traverse(nodes, depth);
+        return result;
+    };
+    const flatItems = flattenTree(treeData);
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(flatItems.length - 1, prev + 1));
+        }
+        else if (key.rightArrow) {
+            const current = flatItems[selectedIndex];
+            if (current.node.type === 'directory' && !current.node.expanded) {
+                const newTrees = updateNodeAtPath(treeData, current.path, (node) => ({
+                    ...node,
+                    expanded: true,
+                }));
+                setTreeData(newTrees);
+            }
+        }
+        else if (key.leftArrow) {
+            const current = flatItems[selectedIndex];
+            if (current.node.type === 'directory' && current.node.expanded) {
+                const newTrees = updateNodeAtPath(treeData, current.path, (node) => ({
+                    ...node,
+                    expanded: false,
+                }));
+                setTreeData(newTrees);
+            }
+        }
+        else if (input === ' ') {
+            const current = flatItems[selectedIndex];
+            const newTrees = toggleNodeSelection(treeData, current.path);
+            setTreeData(newTrees);
+        }
+        else if (input === 'r' && onRefresh) {
+            onRefresh();
+        }
+        else if (key.return) {
+            onSubmit(treeData);
+        }
+        else if (key.escape || input === 'q') {
+            onCancel();
+        }
+    });
+    return (jsx(Box, { flexDirection: "column", children: flatItems.map((item, index) => (jsx(AssetTreeNode, { node: item.node, depth: item.depth, isSelected: index === selectedIndex, onToggle: () => {
+                const newTrees = toggleNodeSelection(treeData, item.path);
+                setTreeData(newTrees);
+            } }, item.path.join('-')))) }));
+};
+function updateNodeAtPath(trees, path, updater) {
+    if (path.length === 0)
+        return trees;
+    const [index, ...rest] = path;
+    const newTrees = [...trees];
+    if (rest.length === 0) {
+        newTrees[index] = updater(newTrees[index]);
+    }
+    else if (newTrees[index].children) {
+        newTrees[index] = {
+            ...newTrees[index],
+            children: updateNodeAtPath(newTrees[index].children, rest, updater),
+        };
+    }
+    return newTrees;
+}
+function toggleNodeSelection(trees, path) {
+    const updatedTrees = updateNodeAtPath(trees, path, (node) => {
+        const newSelected = !node.selected;
+        return toggleNodeAndChildren(node, newSelected);
+    });
+    return updateAncestors(updatedTrees, path);
+}
+function toggleNodeAndChildren(node, selected) {
+    const newNode = { ...node, selected };
+    if (node.children) {
+        newNode.children = node.children.map((child) => toggleNodeAndChildren(child, selected));
+    }
+    return newNode;
+}
+function updateAncestors(trees, path) {
+    if (path.length <= 1) {
+        return trees;
+    }
+    const parentPath = path.slice(0, -1);
+    const updatedTrees = updateNodeAtPath(trees, parentPath, (parentNode) => {
+        if (!parentNode.children || parentNode.children.length === 0) {
+            return parentNode;
+        }
+        const anySelected = parentNode.children.some((child) => child.selected);
+        return {
+            ...parentNode,
+            selected: anySelected,
+        };
+    });
+    return updateAncestors(updatedTrees, parentPath);
+}
+
+export { TreeSelect };

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

@@ -0,0 +1,4 @@
+export { TreeSelect } from './TreeSelect.js';
+export { AssetTreeNode } from './AssetTreeNode.js';
+export type { TreeSelectProps } from './TreeSelect.js';
+export type { AssetTreeNodeProps } from './AssetTreeNode.js';

package/dist/core/assetStructure.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+require('node:fs');
+require('node:path');
+
+const DEFAULT_ASSET_STRUCTURES = {
+    commands: 'nested',
+    skills: 'flat',
+    agents: 'flat',
+};
+function getAssetStructure(assetType, config) {
+    if (!config) {
+        return DEFAULT_ASSET_STRUCTURES[assetType] || 'flat';
+    }
+    let assetsConfig;
+    if ('assetPath' in config) {
+        assetsConfig = config
+            .assets;
+    }
+    else {
+        assetsConfig = config;
+    }
+    if (assetsConfig?.[assetType]?.structure) {
+        return assetsConfig[assetType].structure;
+    }
+    return DEFAULT_ASSET_STRUCTURES[assetType] || 'nested';
+}
+
+exports.DEFAULT_ASSET_STRUCTURES = DEFAULT_ASSET_STRUCTURES;
+exports.getAssetStructure = getAssetStructure;

package/dist/core/assetStructure.d.ts

@@ -0,0 +1,36 @@
+import type { AssetStructure, AssetsConfig } from '../utils/types';
+import { DEFAULT_ASSET_TYPES } from './constants';
+export { DEFAULT_ASSET_TYPES };
+/**
+ * Default structure configuration for built-in asset types
+ */
+export declare const DEFAULT_ASSET_STRUCTURES: Record<string, AssetStructure>;
+/**
+ * Get the structure type for a given asset type
+ * @param assetType - The asset type to query
+ * @param config - Optional ClaudeConfig or AssetsConfig
+ * @returns The structure type ('nested' or 'flat')
+ */
+export declare function getAssetStructure(assetType: string, config?: AssetsConfig | {
+    assetPath: string;
+    assets?: AssetsConfig;
+}): AssetStructure;
+/**
+ * Detect the structure type of an asset directory
+ * @param dir - Directory path to check
+ * @returns Structure type ('flat' | 'nested') or null if directory doesn't exist
+ */
+export declare function detectStructureType(dir: string): AssetStructure | null;
+/**
+ * Validate that an asset structure value is valid
+ * @param structure - Structure value to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function validateAssetStructure(structure: unknown): structure is AssetStructure;
+/**
+ * Validate and normalize asset structure value
+ * @param structure - Structure value to normalize
+ * @param defaultValue - Default value if validation fails
+ * @returns Validated structure or default
+ */
+export declare function normalizeAssetStructure(structure: unknown, defaultValue?: AssetStructure): AssetStructure;

package/dist/core/assetStructure.mjs

@@ -0,0 +1,27 @@
+import 'node:fs';
+import 'node:path';
+
+const DEFAULT_ASSET_STRUCTURES = {
+    commands: 'nested',
+    skills: 'flat',
+    agents: 'flat',
+};
+function getAssetStructure(assetType, config) {
+    if (!config) {
+        return DEFAULT_ASSET_STRUCTURES[assetType] || 'flat';
+    }
+    let assetsConfig;
+    if ('assetPath' in config) {
+        assetsConfig = config
+            .assets;
+    }
+    else {
+        assetsConfig = config;
+    }
+    if (assetsConfig?.[assetType]?.structure) {
+        return assetsConfig[assetType].structure;
+    }
+    return DEFAULT_ASSET_STRUCTURES[assetType] || 'nested';
+}
+
+export { DEFAULT_ASSET_STRUCTURES, getAssetStructure };

package/dist/core/cli.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var commander = require('commander');
+var sync = require('../commands/sync.cjs');
+var list = require('../commands/list.cjs');
+var remove = require('../commands/remove.cjs');
+var status = require('../commands/status.cjs');
+var migrate = require('../commands/migrate.cjs');
+var add = require('../commands/add.cjs');
+var version = require('../version.cjs');
+
+const createProgram = () => {
+    const program = new commander.Command();
+    program
+        .name('claude-assets-sync')
+        .description('Sync Claude commands and skills from npm packages to your project')
+        .version(version.VERSION);
+    program
+        .command('sync', { isDefault: true })
+        .description('Sync Claude assets from npm packages')
+        .option('-p, --package <name>', 'Package name to sync (can be specified multiple times)', (value, previous) => [...previous, value], [])
+        .option('-f, --force', 'Force sync even if version matches', false)
+        .option('--dry-run', 'Preview changes without writing files', false)
+        .option('-l, --local', 'Read packages from local workspace instead of node_modules', false)
+        .option('-r, --ref <ref>', 'Git ref (branch, tag, or commit) to fetch from (overrides version tag)')
+        .option('--no-flat', 'Use legacy nested directory structure instead of flat structure (default: flat)')
+        .action(async (opts) => {
+        await sync.runSyncCommand({
+            package: opts.package,
+            force: opts.force,
+            dryRun: opts.dryRun,
+            local: opts.local,
+            ref: opts.ref,
+            flat: opts.flat,
+        });
+    });
+    program
+        .command('add')
+        .description('Add a package with interactive asset selection')
+        .requiredOption('-p, --package <name>', 'Package name to add')
+        .option('-l, --local', 'Read packages from local workspace instead of node_modules', false)
+        .option('-r, --ref <ref>', 'Git ref (branch, tag, or commit) to fetch from')
+        .action(async (opts) => {
+        await add.runAddCommand({
+            package: opts.package,
+            local: opts.local,
+            ref: opts.ref,
+        });
+    });
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await list.runListCommand({ json: opts.json });
+    });
+    program
+        .command('remove')
+        .description('Remove a synced package')
+        .requiredOption('-p, --package <name>', 'Package name to remove')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--dry-run', 'Preview changes without removing files')
+        .action(async (opts) => {
+        await remove.runRemoveCommand({
+            package: opts.package,
+            yes: opts.yes,
+            dryRun: opts.dryRun,
+        });
+    });
+    program
+        .command('status')
+        .description('Show sync status of all packages')
+        .option('--no-remote', 'Skip remote version check')
+        .action(async (opts) => {
+        await status.runStatusCommand({ noRemote: !opts.remote });
+    });
+    program
+        .command('migrate')
+        .description('Migrate from legacy nested structure to flat structure')
+        .option('--dry-run', 'Preview migration without making changes')
+        .action(async (opts) => {
+        await migrate.runMigrateCommand({ dryRun: opts.dryRun });
+    });
+    return program;
+};
+const run = async () => {
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+};
+
+exports.createProgram = createProgram;
+exports.run = run;

package/dist/core/cli.mjs

@@ -0,0 +1,89 @@
+import { Command } from 'commander';
+import { runSyncCommand } from '../commands/sync.mjs';
+import { runListCommand } from '../commands/list.mjs';
+import { runRemoveCommand } from '../commands/remove.mjs';
+import { runStatusCommand } from '../commands/status.mjs';
+import { runMigrateCommand } from '../commands/migrate.mjs';
+import { runAddCommand } from '../commands/add.mjs';
+import { VERSION } from '../version.mjs';
+
+const createProgram = () => {
+    const program = new Command();
+    program
+        .name('claude-assets-sync')
+        .description('Sync Claude commands and skills from npm packages to your project')
+        .version(VERSION);
+    program
+        .command('sync', { isDefault: true })
+        .description('Sync Claude assets from npm packages')
+        .option('-p, --package <name>', 'Package name to sync (can be specified multiple times)', (value, previous) => [...previous, value], [])
+        .option('-f, --force', 'Force sync even if version matches', false)
+        .option('--dry-run', 'Preview changes without writing files', false)
+        .option('-l, --local', 'Read packages from local workspace instead of node_modules', false)
+        .option('-r, --ref <ref>', 'Git ref (branch, tag, or commit) to fetch from (overrides version tag)')
+        .option('--no-flat', 'Use legacy nested directory structure instead of flat structure (default: flat)')
+        .action(async (opts) => {
+        await runSyncCommand({
+            package: opts.package,
+            force: opts.force,
+            dryRun: opts.dryRun,
+            local: opts.local,
+            ref: opts.ref,
+            flat: opts.flat,
+        });
+    });
+    program
+        .command('add')
+        .description('Add a package with interactive asset selection')
+        .requiredOption('-p, --package <name>', 'Package name to add')
+        .option('-l, --local', 'Read packages from local workspace instead of node_modules', false)
+        .option('-r, --ref <ref>', 'Git ref (branch, tag, or commit) to fetch from')
+        .action(async (opts) => {
+        await runAddCommand({
+            package: opts.package,
+            local: opts.local,
+            ref: opts.ref,
+        });
+    });
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await runListCommand({ json: opts.json });
+    });
+    program
+        .command('remove')
+        .description('Remove a synced package')
+        .requiredOption('-p, --package <name>', 'Package name to remove')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--dry-run', 'Preview changes without removing files')
+        .action(async (opts) => {
+        await runRemoveCommand({
+            package: opts.package,
+            yes: opts.yes,
+            dryRun: opts.dryRun,
+        });
+    });
+    program
+        .command('status')
+        .description('Show sync status of all packages')
+        .option('--no-remote', 'Skip remote version check')
+        .action(async (opts) => {
+        await runStatusCommand({ noRemote: !opts.remote });
+    });
+    program
+        .command('migrate')
+        .description('Migrate from legacy nested structure to flat structure')
+        .option('--dry-run', 'Preview migration without making changes')
+        .action(async (opts) => {
+        await runMigrateCommand({ dryRun: opts.dryRun });
+    });
+    return program;
+};
+const run = async () => {
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+};
+
+export { createProgram, run };

package/dist/core/constants.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var version = require('../version.cjs');
+
+const CLAUDE_BASE_DIR = '.claude';
+const META_FILES = {
+    SYNC_META: '.sync-meta.json',
+    UNIFIED_SYNC_META: '.claude/.sync-meta.json',
+};
+const SCHEMA_VERSIONS = {
+    UNIFIED_SYNC_META: version.VERSION};
+const DEFAULT_ASSET_TYPES = ['commands', 'skills', 'agents'];
+const FS_PATTERNS = {
+    GITHUB_HTTPS_URL: /https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/,
+    GITHUB_SSH_URL: /git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/,
+    GITHUB_SHORTHAND: /^github:([^/]+)\/([^/]+)$/,
+};
+
+exports.CLAUDE_BASE_DIR = CLAUDE_BASE_DIR;
+exports.DEFAULT_ASSET_TYPES = DEFAULT_ASSET_TYPES;
+exports.FS_PATTERNS = FS_PATTERNS;
+exports.META_FILES = META_FILES;
+exports.SCHEMA_VERSIONS = SCHEMA_VERSIONS;