@slats/claude-assets-sync 0.1.3 → 0.2.0

package/dist/core/migration.d.ts

@@ -1,57 +0,0 @@
-/**
- * Result of migration operation
- */
-export interface MigrationResult {
-    /** Whether migration completed successfully */
-    success: boolean;
-    /** List of package names that were migrated */
-    migratedPackages: string[];
-    /** List of errors encountered during migration */
-    errors?: string[];
-}
-/**
- * Check if migration from nested to flat structure is needed
- * Scans for legacy nested directory patterns: .claude/{commands,skills}/@scope/package/
- *
- * @param cwd - Current working directory (project root)
- * @returns true if legacy nested directories exist
- *
- * @example
- * ```ts
- * if (needsMigration(process.cwd())) {
- *   console.log('Legacy structure detected, migration recommended');
- * }
- * ```
- */
-export declare function needsMigration(cwd: string): boolean;
-/**
- * Migrate from legacy nested structure to flat structure
- *
- * Process:
- * 1. Scan .claude/{commands,skills}/@scope/package/ directories
- * 2. Read legacy .sync-meta.json files from each package
- * 3. Copy files to flat structure with name prefixes (scope-package_filename.md)
- * 4. Create or update unified .sync-meta.json
- * 5. Remove empty legacy directories (if not dry-run)
- *
- * @param cwd - Current working directory (project root)
- * @param options - Migration options
- * @param options.dryRun - If true, only simulate migration without making changes
- * @returns Migration result with success status and list of migrated packages
- *
- * @example
- * ```ts
- * // Preview migration without making changes
- * const preview = await migrateToFlat(process.cwd(), { dryRun: true });
- * console.log(`Would migrate ${preview.migratedPackages.length} packages`);
- *
- * // Perform actual migration
- * const result = await migrateToFlat(process.cwd(), { dryRun: false });
- * if (result.success) {
- *   console.log(`Successfully migrated: ${result.migratedPackages.join(', ')}`);
- * }
- * ```
- */
-export declare function migrateToFlat(cwd: string, options?: {
-    dryRun?: boolean;
-}): Promise<MigrationResult>;

package/dist/core/migration.mjs

@@ -1,198 +0,0 @@
-import { existsSync, readdirSync, statSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { toFlatFileName } from '../utils/nameTransform.mjs';
-import { packageNameToPrefix } from '../utils/packageName.mjs';
-import { writeFlatAssetFile } from './filesystem.mjs';
-import { readUnifiedSyncMeta, createEmptyUnifiedMeta, updatePackageInMeta, writeUnifiedSyncMeta } from './syncMeta.mjs';
-
-function needsMigration(cwd) {
-    const assetTypes = ['commands', 'skills'];
-    for (const assetType of assetTypes) {
-        const assetDir = join(cwd, '.claude', assetType);
-        if (!existsSync(assetDir)) {
-            continue;
-        }
-        try {
-            const entries = readdirSync(assetDir);
-            for (const entry of entries) {
-                if (entry.startsWith('@')) {
-                    const scopeDir = join(assetDir, entry);
-                    if (statSync(scopeDir).isDirectory()) {
-                        return true;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error scanning ${assetDir}:`, error);
-            continue;
-        }
-    }
-    return false;
-}
-async function migrateToFlat(cwd, options = {}) {
-    const { dryRun = false } = options;
-    const migratedPackages = [];
-    const errors = [];
-    console.log(`\n🔄 Starting migration to flat structure${dryRun ? ' (DRY RUN)' : ''}...`);
-    let unifiedMeta = readUnifiedSyncMeta(cwd);
-    if (!unifiedMeta) {
-        console.log('📝 Creating new unified sync metadata');
-        unifiedMeta = createEmptyUnifiedMeta();
-    }
-    const assetTypes = ['commands', 'skills'];
-    const legacyDirs = [];
-    for (const assetType of assetTypes) {
-        const assetDir = join(cwd, '.claude', assetType);
-        if (!existsSync(assetDir)) {
-            continue;
-        }
-        console.log(`\n📂 Scanning ${assetType}...`);
-        try {
-            const scopeDirs = readdirSync(assetDir).filter((entry) => {
-                const fullPath = join(assetDir, entry);
-                return entry.startsWith('@') && statSync(fullPath).isDirectory();
-            });
-            for (const scopeDir of scopeDirs) {
-                const scopePath = join(assetDir, scopeDir);
-                const packageDirs = readdirSync(scopePath).filter((entry) => {
-                    const fullPath = join(scopePath, entry);
-                    return statSync(fullPath).isDirectory();
-                });
-                for (const packageDir of packageDirs) {
-                    const packagePath = join(scopePath, packageDir);
-                    const packageName = `${scopeDir}/${packageDir}`;
-                    console.log(`  📦 Processing ${packageName}...`);
-                    try {
-                        const metaPath = join(packagePath, '.sync-meta.json');
-                        let legacyMeta = null;
-                        if (existsSync(metaPath)) {
-                            const metaContent = readFileSync(metaPath, 'utf-8');
-                            legacyMeta = JSON.parse(metaContent);
-                        }
-                        if (!legacyMeta) {
-                            console.log(`    ⚠️  No .sync-meta.json found, skipping`);
-                            continue;
-                        }
-                        const prefix = packageNameToPrefix(packageName);
-                        const commandUnits = [];
-                        const skillUnits = [];
-                        for (const fileName of legacyMeta.files) {
-                            const sourcePath = join(packagePath, fileName);
-                            if (!existsSync(sourcePath)) {
-                                console.log(`    ⚠️  File not found: ${fileName}`);
-                                continue;
-                            }
-                            if (assetType === 'commands') {
-                                if (!dryRun) {
-                                    const content = readFileSync(sourcePath, 'utf-8');
-                                    writeFlatAssetFile(cwd, assetType, fileName, content);
-                                    console.log(`    ✅ Migrated: ${fileName}`);
-                                }
-                                else {
-                                    console.log(`    🔍 Would migrate: ${fileName}`);
-                                }
-                                commandUnits.push({ name: fileName, isDirectory: false });
-                            }
-                            else {
-                                const flatFileName = toFlatFileName(prefix, fileName);
-                                if (!dryRun) {
-                                    const content = readFileSync(sourcePath, 'utf-8');
-                                    writeFlatAssetFile(cwd, assetType, flatFileName, content);
-                                    console.log(`    ✅ Migrated: ${fileName} → ${flatFileName}`);
-                                }
-                                else {
-                                    console.log(`    🔍 Would migrate: ${fileName} → ${flatFileName}`);
-                                }
-                                skillUnits.push({
-                                    name: fileName,
-                                    isDirectory: false,
-                                    transformed: flatFileName,
-                                });
-                            }
-                        }
-                        const packageInfo = {
-                            originalName: packageName,
-                            version: legacyMeta.version,
-                            files: {
-                                commands: assetType === 'commands' ? commandUnits : [],
-                                skills: assetType === 'skills' ? skillUnits : [],
-                                agents: [],
-                            },
-                        };
-                        if (unifiedMeta.packages[prefix]) {
-                            const existing = unifiedMeta.packages[prefix];
-                            if (assetType === 'commands') {
-                                packageInfo.files.skills = existing.files.skills;
-                                packageInfo.files.agents = existing.files.agents;
-                            }
-                            else if (assetType === 'skills') {
-                                packageInfo.files.commands = existing.files.commands;
-                                packageInfo.files.agents = existing.files.agents;
-                            }
-                            else {
-                                packageInfo.files.commands = existing.files.commands;
-                                packageInfo.files.skills = existing.files.skills;
-                            }
-                        }
-                        unifiedMeta = updatePackageInMeta(unifiedMeta, prefix, packageInfo);
-                        migratedPackages.push(packageName);
-                        legacyDirs.push(packagePath);
-                    }
-                    catch (error) {
-                        const errorMsg = `Failed to migrate ${packageName}: ${error}`;
-                        console.error(`    ❌ ${errorMsg}`);
-                        errors.push(errorMsg);
-                    }
-                }
-                legacyDirs.push(scopePath);
-            }
-        }
-        catch (error) {
-            const errorMsg = `Error scanning ${assetType}: ${error}`;
-            console.error(`❌ ${errorMsg}`);
-            errors.push(errorMsg);
-        }
-    }
-    if (!dryRun && migratedPackages.length > 0) {
-        writeUnifiedSyncMeta(cwd, unifiedMeta);
-        console.log(`\n💾 Updated unified sync metadata`);
-    }
-    if (!dryRun && legacyDirs.length > 0) {
-        console.log(`\n🧹 Cleaning up legacy directories...`);
-        for (const legacyDir of legacyDirs) {
-            try {
-                if (existsSync(legacyDir)) {
-                    const entries = readdirSync(legacyDir);
-                    const hasOnlyMeta = entries.length === 1 && entries[0] === '.sync-meta.json';
-                    const isEmpty = entries.length === 0;
-                    if (isEmpty || hasOnlyMeta) {
-                        rmSync(legacyDir, { recursive: true, force: true });
-                        console.log(`  ✅ Removed: ${legacyDir}`);
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`  ⚠️  Failed to remove ${legacyDir}:`, error);
-            }
-        }
-    }
-    console.log(`\n📊 Migration Summary:`);
-    console.log(`  ✅ Migrated packages: ${migratedPackages.length}`);
-    if (errors.length > 0) {
-        console.log(`  ❌ Errors: ${errors.length}`);
-    }
-    if (dryRun) {
-        console.log(`\n🔍 DRY RUN: No changes were made. Run without --dry-run to apply migration.`);
-    }
-    else if (migratedPackages.length > 0) {
-        console.log(`\n✨ Migration completed successfully!`);
-    }
-    return {
-        success: errors.length === 0,
-        migratedPackages,
-        errors: errors.length > 0 ? errors : undefined,
-    };
-}
-
-export { migrateToFlat, needsMigration };

package/dist/core/packageScanner.cjs

@@ -1,360 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var nameTransform = require('../utils/nameTransform.cjs');
-var _package = require('../utils/package.cjs');
-var constants = require('./constants.cjs');
-var github = require('./github.cjs');
-
-function readPackageJsonFromPath(packagePath) {
-    try {
-        const packageJsonPath = path.join(packagePath, 'package.json');
-        if (!fs.existsSync(packageJsonPath)) {
-            return null;
-        }
-        const content = fs.readFileSync(packageJsonPath, 'utf-8');
-        const json = JSON.parse(content);
-        return {
-            name: json.name,
-            version: json.version,
-            repository: json.repository,
-            claude: json.claude,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-async function scanPackageAssets(packageName, options) {
-    const cwd = options.cwd ?? process.cwd();
-    if (options.local) {
-        return scanLocalAssets(packageName, cwd);
-    }
-    return scanRemoteAssets(packageName, cwd, options.ref);
-}
-async function scanLocalAssets(packageName, cwd) {
-    const packagePath = findLocalPackage(packageName, cwd);
-    if (!packagePath) {
-        throw new Error(`Package ${packageName} not found in local workspace`);
-    }
-    const pkgInfo = readPackageJsonFromPath(packagePath);
-    if (!pkgInfo) {
-        throw new Error(`Package ${packageName} not found in local workspace`);
-    }
-    const claudeConfig = _package.resolveClaudeConfig(pkgInfo.claude);
-    const assetPath = path.join(packagePath, claudeConfig.assetPath);
-    if (!fs.existsSync(assetPath)) {
-        throw new Error(`Asset path ${assetPath} does not exist`);
-    }
-    const trees = [];
-    for (const assetType of constants.DEFAULT_ASSET_TYPES) {
-        const assetDir = path.join(assetPath, assetType);
-        if (!fs.existsSync(assetDir)) {
-            continue;
-        }
-        const tree = buildTreeFromLocalDir(assetType, assetDir, assetType);
-        if (tree.children && tree.children.length > 0) {
-            trees.push(tree);
-        }
-    }
-    return trees;
-}
-async function scanRemoteAssets(packageName, cwd, ref) {
-    const nodeModulesPath = _package.resolvePackagePath(packageName, cwd);
-    if (!nodeModulesPath) {
-        throw new Error(`Package ${packageName} not found`);
-    }
-    const pkgInfo = readPackageJsonFromPath(nodeModulesPath);
-    if (!pkgInfo) {
-        throw new Error(`Package ${packageName} not found`);
-    }
-    const claudeConfig = _package.resolveClaudeConfig(pkgInfo.claude);
-    const assetBasePath = claudeConfig.assetPath;
-    if (!ref) {
-        const localDocsPath = path.join(nodeModulesPath, assetBasePath);
-        if (fs.existsSync(localDocsPath)) {
-            const trees = [];
-            for (const assetType of constants.DEFAULT_ASSET_TYPES) {
-                const assetDir = path.join(localDocsPath, assetType);
-                if (!fs.existsSync(assetDir))
-                    continue;
-                const tree = buildTreeFromLocalDir(assetType, assetDir, assetType);
-                if (tree.children && tree.children.length > 0) {
-                    trees.push(tree);
-                }
-            }
-            if (trees.length > 0)
-                return trees;
-        }
-    }
-    if (!pkgInfo.repository) {
-        throw new Error(`Package ${packageName} has no repository field`);
-    }
-    const repoInfo = _package.parseGitHubRepo(pkgInfo.repository);
-    if (!repoInfo) {
-        throw new Error(`Invalid GitHub repository URL in package ${packageName}`);
-    }
-    const tag = ref ?? 'HEAD';
-    const trees = [];
-    for (const assetType of constants.DEFAULT_ASSET_TYPES) {
-        const assetPath = repoInfo.directory
-            ? `${repoInfo.directory}/${assetBasePath}/${assetType}`
-            : `${assetBasePath}/${assetType}`;
-        try {
-            const entries = await github.fetchDirectoryContents(repoInfo, assetPath, tag);
-            if (entries && entries.length > 0) {
-                const dirContentsMap = new Map();
-                for (const entry of entries) {
-                    if (entry.type === 'dir') {
-                        const dirEntries = await github.fetchDirectoryContents(repoInfo, `${assetPath}/${entry.name}`, tag);
-                        if (dirEntries) {
-                            dirContentsMap.set(entry.name, dirEntries);
-                        }
-                    }
-                }
-                const tree = buildTreeFromGitHubEntries(assetType, entries, assetType, dirContentsMap);
-                if (tree.children && tree.children.length > 0) {
-                    trees.push(tree);
-                }
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return trees;
-}
-function scanDirectoryRecursive(dirPath, prefix) {
-    const results = [];
-    try {
-        const entries = fs.readdirSync(dirPath);
-        for (const entry of entries) {
-            const fullPath = path.join(dirPath, entry);
-            const relativePath = prefix ? `${prefix}/${entry}` : entry;
-            const stat = fs.statSync(fullPath);
-            if (stat.isDirectory()) {
-                results.push(...scanDirectoryRecursive(fullPath, relativePath));
-            }
-            else {
-                results.push(relativePath);
-            }
-        }
-    }
-    catch {
-    }
-    return results;
-}
-function buildTreeFromLocalDir(label, dirPath, basePath) {
-    const entries = fs.readdirSync(dirPath);
-    const children = [];
-    for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry);
-        const stat = fs.statSync(fullPath);
-        const relativePath = path.join(basePath, entry);
-        if (stat.isDirectory()) {
-            const isSkill = fs.existsSync(path.join(fullPath, 'SKILL.md')) ||
-                fs.existsSync(path.join(fullPath, 'Skill.md'));
-            if (isSkill) {
-                const internalFiles = scanDirectoryRecursive(fullPath, '');
-                const internalChildren = internalFiles.map((f) => ({
-                    id: `${relativePath}/${f}`,
-                    label: f,
-                    path: `${relativePath}/${f}`,
-                    type: 'file',
-                    selected: true,
-                    expanded: false,
-                    disabled: true,
-                }));
-                children.push({
-                    id: relativePath,
-                    label: entry,
-                    path: relativePath,
-                    type: 'skill-directory',
-                    children: internalChildren,
-                    viewOnly: true,
-                    selected: true,
-                    expanded: false,
-                });
-            }
-            else {
-                const subTree = buildTreeFromLocalDir(entry, fullPath, relativePath);
-                if (subTree.children && subTree.children.length > 0) {
-                    children.push(subTree);
-                }
-            }
-        }
-        else {
-            children.push({
-                id: relativePath,
-                label: entry,
-                path: relativePath,
-                type: 'file',
-                selected: true,
-                expanded: false,
-            });
-        }
-    }
-    return {
-        id: basePath,
-        label,
-        path: basePath,
-        type: 'directory',
-        children,
-        selected: true,
-        expanded: true,
-    };
-}
-function buildTreeFromGitHubEntries(label, entries, basePath, dirContentsMap) {
-    const children = [];
-    for (const entry of entries) {
-        if (entry.type === 'file') {
-            children.push({
-                id: entry.path,
-                label: entry.name,
-                path: entry.path,
-                type: 'file',
-                selected: true,
-                expanded: false,
-            });
-        }
-        else if (entry.type === 'dir') {
-            const dirEntries = dirContentsMap?.get(entry.name);
-            const hasSkillMd = dirEntries ? isDirectorySkill(dirEntries) : false;
-            if (hasSkillMd) {
-                const skillPath = `${basePath}/${entry.name}`;
-                const internalChildren = dirEntries
-                    ? dirEntries.map((de) => ({
-                        id: `${skillPath}/${de.name}`,
-                        label: de.name,
-                        path: `${skillPath}/${de.name}`,
-                        type: 'file',
-                        selected: true,
-                        expanded: false,
-                        disabled: true,
-                    }))
-                    : [];
-                children.push({
-                    id: skillPath,
-                    label: entry.name,
-                    path: skillPath,
-                    type: 'skill-directory',
-                    children: internalChildren,
-                    viewOnly: true,
-                    selected: true,
-                    expanded: false,
-                });
-            }
-            else if (dirEntries && dirEntries.length > 0) {
-                const subTree = buildTreeFromGitHubEntries(entry.name, dirEntries, `${basePath}/${entry.name}`);
-                if (subTree.children && subTree.children.length > 0) {
-                    children.push(subTree);
-                }
-            }
-        }
-    }
-    return {
-        id: basePath,
-        label,
-        path: basePath,
-        type: 'directory',
-        children,
-        selected: true,
-        expanded: true,
-    };
-}
-function isDirectorySkill(entries) {
-    return entries.some((entry) => entry.type === 'file' &&
-        (entry.name === 'SKILL.md' || entry.name === 'Skill.md'));
-}
-function findLocalPackage(packageName, cwd) {
-    const monorepoRoot = findMonorepoRoot(cwd);
-    const searchRoot = monorepoRoot || cwd;
-    const packagesDir = path.join(searchRoot, 'packages');
-    if (fs.existsSync(packagesDir)) {
-        const found = searchPackagesRecursively(packagesDir, packageName);
-        if (found)
-            return found;
-    }
-    const nodeModulesPath = path.join(searchRoot, 'node_modules', packageName);
-    if (fs.existsSync(nodeModulesPath)) {
-        return nodeModulesPath;
-    }
-    return null;
-}
-function findMonorepoRoot(startDir) {
-    let currentDir = startDir;
-    const root = '/';
-    while (currentDir !== root) {
-        const pkgJsonPath = path.join(currentDir, 'package.json');
-        if (fs.existsSync(pkgJsonPath)) {
-            try {
-                const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-                if (pkgJson.workspaces) {
-                    return currentDir;
-                }
-            }
-            catch {
-            }
-        }
-        currentDir = path.join(currentDir, '..');
-    }
-    return null;
-}
-function searchPackagesRecursively(dir, packageName) {
-    try {
-        const entries = fs.readdirSync(dir);
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry);
-            const stat = fs.statSync(fullPath);
-            if (stat.isDirectory()) {
-                const pkgJsonPath = path.join(fullPath, 'package.json');
-                if (fs.existsSync(pkgJsonPath)) {
-                    const pkgInfo = readPackageJsonFromPath(fullPath);
-                    if (pkgInfo && pkgInfo.name === packageName) {
-                        return fullPath;
-                    }
-                }
-                const found = searchPackagesRecursively(fullPath, packageName);
-                if (found)
-                    return found;
-            }
-        }
-    }
-    catch {
-    }
-    return null;
-}
-function buildSkillUnitsFromTree(tree, prefix) {
-    if (!tree.children)
-        return [];
-    const units = [];
-    for (const child of tree.children) {
-        if (child.type === 'skill-directory') {
-            const internalFiles = child.children
-                ? child.children.map((c) => c.label)
-                : [];
-            units.push({
-                name: child.label,
-                isDirectory: true,
-                transformed: nameTransform.toFlatFileName(prefix, child.label),
-                internalFiles,
-            });
-        }
-        else if (child.type === 'file') {
-            units.push({
-                name: child.label,
-                isDirectory: false,
-                transformed: nameTransform.toFlatFileName(prefix, child.label),
-            });
-        }
-        else if (child.type === 'directory') {
-            units.push(...buildSkillUnitsFromTree(child, prefix));
-        }
-    }
-    return units;
-}
-
-exports.buildSkillUnitsFromTree = buildSkillUnitsFromTree;
-exports.isDirectorySkill = isDirectorySkill;
-exports.scanPackageAssets = scanPackageAssets;

package/dist/core/packageScanner.d.ts

@@ -1,22 +0,0 @@
-import type { GitHubEntry, SkillUnit, TreeNode } from '../utils/types.js';
-/**
- * Scan package assets from local workspace or GitHub
- *
- * @param packageName - Package name to scan
- * @param options - Scan options
- * @returns Tree structure of available assets
- */
-export declare function scanPackageAssets(packageName: string, options: {
-    local: boolean;
-    ref?: string;
-    cwd?: string;
-}): Promise<TreeNode[]>;
-/**
- * Check if entries represent a directory-based skill
- */
-export declare function isDirectorySkill(entries: GitHubEntry[]): boolean;
-/**
- * Convert a TreeNode asset-type subtree into SkillUnit[] for writing to meta.
- * Used by both `add` and `list` commands when saving.
- */
-export declare function buildSkillUnitsFromTree(tree: TreeNode, prefix: string): SkillUnit[];