@slats/claude-assets-sync 0.0.3 → 0.0.5

package/dist/core/packageScanner.cjs

@@ -3,6 +3,7 @@
 var fs = require('node:fs');
 var path = require('node:path');
 var _package = require('../utils/package.cjs');
+var nameTransform = require('../utils/nameTransform.cjs');
 var constants = require('./constants.cjs');
 var github = require('./github.cjs');
 
@@ -72,15 +73,25 @@ async function scanRemoteAssets(packageName, ref) {
         throw new Error(`Invalid GitHub repository URL in package ${packageName}`);
     }
     const assetBasePath = pkgInfo.claude.assetPath;
+    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, ref ?? 'HEAD');
+            const entries = await github.fetchDirectoryContents(repoInfo, assetPath, tag);
             if (entries && entries.length > 0) {
-                const tree = buildTreeFromGitHubEntries(assetType, entries, assetType);
+                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);
                 }
@@ -92,6 +103,26 @@ async function scanRemoteAssets(packageName, ref) {
     }
     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 = [];
@@ -100,13 +131,26 @@ function buildTreeFromLocalDir(label, dirPath, basePath) {
         const stat = fs.statSync(fullPath);
         const relativePath = path.join(basePath, entry);
         if (stat.isDirectory()) {
-            const isSkill = fs.existsSync(path.join(fullPath, 'Skill.md'));
+            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,
                 });
@@ -139,36 +183,50 @@ function buildTreeFromLocalDir(label, dirPath, basePath) {
         expanded: true,
     };
 }
-function buildTreeFromGitHubEntries(label, entries, basePath) {
+function buildTreeFromGitHubEntries(label, entries, basePath, dirContentsMap) {
     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;
+    for (const entry of entries) {
+        if (entry.type === 'file') {
             children.push({
-                id: filePath,
-                label: name,
-                path: filePath,
+                id: entry.path,
+                label: entry.name,
+                path: entry.path,
                 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}`;
+        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: name,
+                    label: entry.name,
                     path: skillPath,
                     type: 'skill-directory',
+                    children: internalChildren,
+                    viewOnly: true,
                     selected: true,
                     expanded: false,
                 });
             }
-            else {
-                const subTree = buildTreeFromGitHubEntries(name, items, `${basePath}/${name}`);
+            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);
                 }
@@ -185,17 +243,9 @@ function buildTreeFromGitHubEntries(label, entries, basePath) {
         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 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);
@@ -255,5 +305,36 @@ function searchPackagesRecursively(dir, packageName) {
     }
     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,4 +1,4 @@
-import type { GitHubEntry, TreeNode } from '../utils/types.js';
+import type { GitHubEntry, SkillUnit, TreeNode } from '../utils/types.js';
 /**
  * Scan package assets from local workspace or GitHub
  *
@@ -15,3 +15,8 @@ export declare function scanPackageAssets(packageName: string, options: {
  * 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[];

package/dist/core/packageScanner.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseGitHubRepo } from '../utils/package.mjs';
+import { toFlatFileName } from '../utils/nameTransform.mjs';
 import { DEFAULT_ASSET_TYPES } from './constants.mjs';
 import { fetchDirectoryContents } from './github.mjs';
 
@@ -70,15 +71,25 @@ async function scanRemoteAssets(packageName, ref) {
         throw new Error(`Invalid GitHub repository URL in package ${packageName}`);
     }
     const assetBasePath = pkgInfo.claude.assetPath;
+    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, ref ?? 'HEAD');
+            const entries = await fetchDirectoryContents(repoInfo, assetPath, tag);
             if (entries && entries.length > 0) {
-                const tree = buildTreeFromGitHubEntries(assetType, entries, assetType);
+                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);
                 }
@@ -90,6 +101,26 @@ async function scanRemoteAssets(packageName, ref) {
     }
     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 = [];
@@ -98,13 +129,26 @@ function buildTreeFromLocalDir(label, dirPath, basePath) {
         const stat = statSync(fullPath);
         const relativePath = join(basePath, entry);
         if (stat.isDirectory()) {
-            const isSkill = existsSync(join(fullPath, 'Skill.md'));
+            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,
                 });
@@ -137,36 +181,50 @@ function buildTreeFromLocalDir(label, dirPath, basePath) {
         expanded: true,
     };
 }
-function buildTreeFromGitHubEntries(label, entries, basePath) {
+function buildTreeFromGitHubEntries(label, entries, basePath, dirContentsMap) {
     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;
+    for (const entry of entries) {
+        if (entry.type === 'file') {
             children.push({
-                id: filePath,
-                label: name,
-                path: filePath,
+                id: entry.path,
+                label: entry.name,
+                path: entry.path,
                 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}`;
+        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: name,
+                    label: entry.name,
                     path: skillPath,
                     type: 'skill-directory',
+                    children: internalChildren,
+                    viewOnly: true,
                     selected: true,
                     expanded: false,
                 });
             }
-            else {
-                const subTree = buildTreeFromGitHubEntries(name, items, `${basePath}/${name}`);
+            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);
                 }
@@ -183,17 +241,9 @@ function buildTreeFromGitHubEntries(label, entries, basePath) {
         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 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);
@@ -253,5 +303,34 @@ function searchPackagesRecursively(dir, packageName) {
     }
     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 { scanPackageAssets };
+export { buildSkillUnitsFromTree, isDirectorySkill, scanPackageAssets };