@slats/claude-assets-sync 0.0.1 → 0.0.2

package/dist/core/packageScanner.cjs

@@ -0,0 +1,259 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+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, 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 || !pkgInfo.claude?.assetPath) {
+        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    }
+    const assetPath = path.join(packagePath, pkgInfo.claude.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, ref) {
+    const nodeModulesPath = path.join(process.cwd(), 'node_modules', packageName);
+    const pkgInfo = readPackageJsonFromPath(nodeModulesPath);
+    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
+        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    }
+    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 assetBasePath = pkgInfo.claude.assetPath;
+    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, ref ?? 'HEAD');
+            if (entries && entries.length > 0) {
+                const tree = buildTreeFromGitHubEntries(assetType, entries, assetType);
+                if (tree.children && tree.children.length > 0) {
+                    trees.push(tree);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return trees;
+}
+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'));
+            if (isSkill) {
+                children.push({
+                    id: relativePath,
+                    label: entry,
+                    path: relativePath,
+                    type: 'skill-directory',
+                    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) {
+    const children = [];
+    const grouped = groupByTopLevel(entries);
+    for (const [name, items] of Object.entries(grouped)) {
+        if (items.length === 1 && items[0].type === 'file') {
+            const filePath = items[0].path;
+            children.push({
+                id: filePath,
+                label: name,
+                path: filePath,
+                type: 'file',
+                selected: true,
+                expanded: false,
+            });
+        }
+        else {
+            const isSkill = items.some((item) => item.type === 'file' && item.name === 'Skill.md');
+            if (isSkill) {
+                const skillPath = `${basePath}/${name}`;
+                children.push({
+                    id: skillPath,
+                    label: name,
+                    path: skillPath,
+                    type: 'skill-directory',
+                    selected: true,
+                    expanded: false,
+                });
+            }
+            else {
+                const subTree = buildTreeFromGitHubEntries(name, items, `${basePath}/${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 groupByTopLevel(entries) {
+    const groups = {};
+    for (const entry of entries) {
+        const parts = entry.path.split('/');
+        const topLevel = parts[parts.length - (entry.type === 'file' ? 1 : 0)];
+        if (!groups[topLevel]) {
+            groups[topLevel] = [];
+        }
+        groups[topLevel].push(entry);
+    }
+    return groups;
+}
+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;
+}
+
+exports.scanPackageAssets = scanPackageAssets;

package/dist/core/packageScanner.d.ts

@@ -0,0 +1,17 @@
+import type { GitHubEntry, 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;

package/dist/core/packageScanner.mjs

@@ -0,0 +1,257 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { 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, 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 || !pkgInfo.claude?.assetPath) {
+        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    }
+    const assetPath = join(packagePath, pkgInfo.claude.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, ref) {
+    const nodeModulesPath = join(process.cwd(), 'node_modules', packageName);
+    const pkgInfo = readPackageJsonFromPath(nodeModulesPath);
+    if (!pkgInfo || !pkgInfo.claude?.assetPath) {
+        throw new Error(`Package ${packageName} has no claude.assetPath configured`);
+    }
+    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 assetBasePath = pkgInfo.claude.assetPath;
+    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, ref ?? 'HEAD');
+            if (entries && entries.length > 0) {
+                const tree = buildTreeFromGitHubEntries(assetType, entries, assetType);
+                if (tree.children && tree.children.length > 0) {
+                    trees.push(tree);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return trees;
+}
+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'));
+            if (isSkill) {
+                children.push({
+                    id: relativePath,
+                    label: entry,
+                    path: relativePath,
+                    type: 'skill-directory',
+                    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) {
+    const children = [];
+    const grouped = groupByTopLevel(entries);
+    for (const [name, items] of Object.entries(grouped)) {
+        if (items.length === 1 && items[0].type === 'file') {
+            const filePath = items[0].path;
+            children.push({
+                id: filePath,
+                label: name,
+                path: filePath,
+                type: 'file',
+                selected: true,
+                expanded: false,
+            });
+        }
+        else {
+            const isSkill = items.some((item) => item.type === 'file' && item.name === 'Skill.md');
+            if (isSkill) {
+                const skillPath = `${basePath}/${name}`;
+                children.push({
+                    id: skillPath,
+                    label: name,
+                    path: skillPath,
+                    type: 'skill-directory',
+                    selected: true,
+                    expanded: false,
+                });
+            }
+            else {
+                const subTree = buildTreeFromGitHubEntries(name, items, `${basePath}/${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 groupByTopLevel(entries) {
+    const groups = {};
+    for (const entry of entries) {
+        const parts = entry.path.split('/');
+        const topLevel = parts[parts.length - (entry.type === 'file' ? 1 : 0)];
+        if (!groups[topLevel]) {
+            groups[topLevel] = [];
+        }
+        groups[topLevel].push(entry);
+    }
+    return groups;
+}
+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;
+}
+
+export { scanPackageAssets };