@slats/claude-assets-sync 0.1.4 → 0.2.0

package/dist/core/packageScanner.mjs

@@ -1,356 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { toFlatFileName } from '../utils/nameTransform.mjs';
-import { resolveClaudeConfig, resolvePackagePath, parseGitHubRepo } from '../utils/package.mjs';
-import { DEFAULT_ASSET_TYPES } from './constants.mjs';
-import { fetchDirectoryContents } from './github.mjs';
-
-function readPackageJsonFromPath(packagePath) {
-    try {
-        const packageJsonPath = join(packagePath, 'package.json');
-        if (!existsSync(packageJsonPath)) {
-            return null;
-        }
-        const content = 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 = resolveClaudeConfig(pkgInfo.claude);
-    const assetPath = join(packagePath, claudeConfig.assetPath);
-    if (!existsSync(assetPath)) {
-        throw new Error(`Asset path ${assetPath} does not exist`);
-    }
-    const trees = [];
-    for (const assetType of DEFAULT_ASSET_TYPES) {
-        const assetDir = join(assetPath, assetType);
-        if (!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 = 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 = resolveClaudeConfig(pkgInfo.claude);
-    const assetBasePath = claudeConfig.assetPath;
-    if (!ref) {
-        const localDocsPath = join(nodeModulesPath, assetBasePath);
-        if (existsSync(localDocsPath)) {
-            const trees = [];
-            for (const assetType of DEFAULT_ASSET_TYPES) {
-                const assetDir = join(localDocsPath, assetType);
-                if (!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 = 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 DEFAULT_ASSET_TYPES) {
-        const assetPath = repoInfo.directory
-            ? `${repoInfo.directory}/${assetBasePath}/${assetType}`
-            : `${assetBasePath}/${assetType}`;
-        try {
-            const entries = await 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 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 = readdirSync(dirPath);
-        for (const entry of entries) {
-            const fullPath = join(dirPath, entry);
-            const relativePath = prefix ? `${prefix}/${entry}` : entry;
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                results.push(...scanDirectoryRecursive(fullPath, relativePath));
-            }
-            else {
-                results.push(relativePath);
-            }
-        }
-    }
-    catch {
-    }
-    return results;
-}
-function buildTreeFromLocalDir(label, dirPath, basePath) {
-    const entries = readdirSync(dirPath);
-    const children = [];
-    for (const entry of entries) {
-        const fullPath = join(dirPath, entry);
-        const stat = statSync(fullPath);
-        const relativePath = join(basePath, entry);
-        if (stat.isDirectory()) {
-            const isSkill = existsSync(join(fullPath, 'SKILL.md')) ||
-                existsSync(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 = join(searchRoot, 'packages');
-    if (existsSync(packagesDir)) {
-        const found = searchPackagesRecursively(packagesDir, packageName);
-        if (found)
-            return found;
-    }
-    const nodeModulesPath = join(searchRoot, 'node_modules', packageName);
-    if (existsSync(nodeModulesPath)) {
-        return nodeModulesPath;
-    }
-    return null;
-}
-function findMonorepoRoot(startDir) {
-    let currentDir = startDir;
-    const root = '/';
-    while (currentDir !== root) {
-        const pkgJsonPath = join(currentDir, 'package.json');
-        if (existsSync(pkgJsonPath)) {
-            try {
-                const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
-                if (pkgJson.workspaces) {
-                    return currentDir;
-                }
-            }
-            catch {
-            }
-        }
-        currentDir = join(currentDir, '..');
-    }
-    return null;
-}
-function searchPackagesRecursively(dir, packageName) {
-    try {
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-            const fullPath = join(dir, entry);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                const pkgJsonPath = join(fullPath, 'package.json');
-                if (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: toFlatFileName(prefix, child.label),
-                internalFiles,
-            });
-        }
-        else if (child.type === 'file') {
-            units.push({
-                name: child.label,
-                isDirectory: false,
-                transformed: toFlatFileName(prefix, child.label),
-            });
-        }
-        else if (child.type === 'directory') {
-            units.push(...buildSkillUnitsFromTree(child, prefix));
-        }
-    }
-    return units;
-}
-
-export { buildSkillUnitsFromTree, isDirectorySkill, scanPackageAssets };