@slats/claude-assets-sync 0.0.2 → 0.0.4

package/dist/cli.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var cli = require('./core/cli.cjs');
+
+cli.run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+});

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from './core/cli.mjs';
+
+run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+});

package/dist/commands/remove.cjs

@@ -6,7 +6,7 @@ var readline = require('node:readline/promises');
 var pc = require('picocolors');
 var syncMeta = require('../core/syncMeta.cjs');
 var logger = require('../utils/logger.cjs');
-var nameTransform = require('../utils/nameTransform.cjs');
+var packageName = require('../utils/packageName.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -30,17 +30,17 @@ var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
-    const { package: packageName, yes, dryRun } = options;
-    const prefix = nameTransform.packageNameToPrefix(packageName);
+    const { package: packageName$1, yes, dryRun } = options;
+    const prefix = packageName.packageNameToPrefix(packageName$1);
     const meta = syncMeta.readUnifiedSyncMeta(cwd);
     if (!meta || !meta.packages || !meta.packages[prefix]) {
-        logger.logger.error(`Package ${packageName} is not synced.`);
+        logger.logger.error(`Package ${packageName$1} is not synced.`);
         process.exit(1);
         return;
     }
     const packageInfo = meta.packages[prefix];
     if (!packageInfo || !packageInfo.files) {
-        logger.logger.error(`Package ${packageName} has no files to remove.`);
+        logger.logger.error(`Package ${packageName$1} has no files to remove.`);
         process.exit(1);
         return;
     }
@@ -57,7 +57,7 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
             }
         }
         else {
-            const dirPath = path__namespace.join(cwd, '.claude', assetType, packageName);
+            const dirPath = path__namespace.join(cwd, '.claude', assetType, packageName$1);
             filesToRemove.push({ assetType, path: dirPath });
         }
     }
@@ -103,7 +103,7 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
     delete meta.packages[prefix];
     meta.syncedAt = new Date().toISOString();
     syncMeta.writeUnifiedSyncMeta(cwd, meta);
-    logger.logger.success(`\nRemoved package ${packageName}`);
+    logger.logger.success(`\nRemoved package ${packageName$1}`);
 };
 
 exports.runRemoveCommand = runRemoveCommand;

package/dist/commands/remove.mjs

@@ -4,7 +4,7 @@ import * as readline from 'node:readline/promises';
 import pc from 'picocolors';
 import { readUnifiedSyncMeta, writeUnifiedSyncMeta } from '../core/syncMeta.mjs';
 import { logger } from '../utils/logger.mjs';
-import { packageNameToPrefix } from '../utils/nameTransform.mjs';
+import { packageNameToPrefix } from '../utils/packageName.mjs';
 
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName, yes, dryRun } = options;

package/dist/core/assetStructure.d.ts

@@ -1,4 +1,4 @@
-import type { AssetStructure, AssetsConfig } from '../utils/types';
+import type { AssetStructure, AssetsConfig } from '../utils/types.js';
 import { DEFAULT_ASSET_TYPES } from './constants';
 export { DEFAULT_ASSET_TYPES };
 /**

package/dist/core/constants.d.ts

@@ -22,7 +22,7 @@ export declare const META_FILES: {
  * Schema versions for metadata files
  */
 export declare const SCHEMA_VERSIONS: {
-    readonly UNIFIED_SYNC_META: "0.0.2";
+    readonly UNIFIED_SYNC_META: "0.0.4";
     readonly LEGACY_SYNC_META: "1.0.0";
 };
 /**

package/dist/core/filesystem.cjs

@@ -58,24 +58,36 @@ const cleanFlatAssetFiles = (cwd, assetType, prefix, existingMeta) => {
         const packageInfo = existingMeta.packages[prefix];
         const filesToRemove = packageInfo.files[assetType];
         if (Array.isArray(filesToRemove)) {
+            const skillDirs = new Set();
             for (const fileMapping of filesToRemove) {
                 const fileName = typeof fileMapping === 'string'
                     ? fileMapping
                     : fileMapping.transformed;
-                const filePath = path.join(destDir, fileName);
-                if (io.fileExists(filePath)) {
-                    fs.rmSync(filePath, { force: true });
+                if (fileName.includes('/')) {
+                    skillDirs.add(fileName.split('/')[0]);
+                }
+                else {
+                    const filePath = path.join(destDir, fileName);
+                    if (io.fileExists(filePath)) {
+                        fs.rmSync(filePath, { force: true });
+                    }
+                }
+            }
+            for (const dir of skillDirs) {
+                const dirPath = path.join(destDir, dir);
+                if (io.fileExists(dirPath)) {
+                    fs.rmSync(dirPath, { recursive: true, force: true });
                 }
             }
         }
     }
     else {
         const pattern = `${prefix}_`;
-        const files = io.listDirectory(destDir);
-        for (const file of files) {
-            if (file.startsWith(pattern) && file.endsWith('.md')) {
-                const filePath = path.join(destDir, file);
-                fs.rmSync(filePath, { force: true });
+        const entries = io.listDirectory(destDir);
+        for (const entry of entries) {
+            if (entry.startsWith(pattern)) {
+                const entryPath = path.join(destDir, entry);
+                fs.rmSync(entryPath, { recursive: true, force: true });
             }
         }
     }

package/dist/core/filesystem.d.ts

@@ -1,4 +1,4 @@
-import type { AssetType, SyncMeta, UnifiedSyncMeta } from '../utils/types';
+import type { AssetType, SyncMeta, UnifiedSyncMeta } from '../utils/types.js';
 import { ensureDirectory, writeTextFile } from './io';
 /**
  * Ensure directory exists (creates recursively if needed)
@@ -71,7 +71,8 @@ export declare const createSyncMeta: (version: string, files: string[]) => SyncM
 export declare const writeFlatAssetFile: (cwd: string, assetType: AssetType, flatFileName: string, content: string) => void;
 /**
  * Clean flat asset files with specific prefix
- * Removes only files belonging to the specified package, preserving others
+ * Removes only files belonging to the specified package, preserving others.
+ * Handles both single flat files (prefix_file.md) and directory-based skills (prefix_dir/).
  * @param cwd - Current working directory
  * @param assetType - Asset type (commands, skills, agents, or any custom string)
  * @param prefix - Package prefix (e.g., "canard-schemaForm")

package/dist/core/filesystem.mjs

@@ -56,24 +56,36 @@ const cleanFlatAssetFiles = (cwd, assetType, prefix, existingMeta) => {
         const packageInfo = existingMeta.packages[prefix];
         const filesToRemove = packageInfo.files[assetType];
         if (Array.isArray(filesToRemove)) {
+            const skillDirs = new Set();
             for (const fileMapping of filesToRemove) {
                 const fileName = typeof fileMapping === 'string'
                     ? fileMapping
                     : fileMapping.transformed;
-                const filePath = join(destDir, fileName);
-                if (fileExists(filePath)) {
-                    rmSync(filePath, { force: true });
+                if (fileName.includes('/')) {
+                    skillDirs.add(fileName.split('/')[0]);
+                }
+                else {
+                    const filePath = join(destDir, fileName);
+                    if (fileExists(filePath)) {
+                        rmSync(filePath, { force: true });
+                    }
+                }
+            }
+            for (const dir of skillDirs) {
+                const dirPath = join(destDir, dir);
+                if (fileExists(dirPath)) {
+                    rmSync(dirPath, { recursive: true, force: true });
                 }
             }
         }
     }
     else {
         const pattern = `${prefix}_`;
-        const files = listDirectory(destDir);
-        for (const file of files) {
-            if (file.startsWith(pattern) && file.endsWith('.md')) {
-                const filePath = join(destDir, file);
-                rmSync(filePath, { force: true });
+        const entries = listDirectory(destDir);
+        for (const entry of entries) {
+            if (entry.startsWith(pattern)) {
+                const entryPath = join(destDir, entry);
+                rmSync(entryPath, { recursive: true, force: true });
             }
         }
     }

package/dist/core/github.cjs

@@ -37,17 +37,44 @@ const fetchDirectoryContents = async (repoInfo, path, tag) => {
     if (!response.ok)
         throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
     const data = await response.json();
-    return data.filter((entry) => entry.type === 'file' && entry.name.endsWith('.md'));
+    return data.filter((entry) => (entry.type === 'file' && entry.name.endsWith('.md')) ||
+        entry.type === 'dir');
+};
+const expandDirectoryEntries = async (repoInfo, parentPath, entries, tag, prefix = '') => {
+    const result = [];
+    for (const entry of entries) {
+        const entryPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'file') {
+            result.push({
+                ...entry,
+                name: prefix ? entryPrefix : entry.name,
+            });
+        }
+        else if (entry.type === 'dir') {
+            const subEntries = await fetchDirectoryContents(repoInfo, `${parentPath}/${entry.name}`, tag);
+            if (subEntries) {
+                const expanded = await expandDirectoryEntries(repoInfo, `${parentPath}/${entry.name}`, subEntries, tag, entryPrefix);
+                result.push(...expanded);
+            }
+        }
+    }
+    return result;
 };
 const fetchAssetFiles = async (repoInfo, assetPath, tag, assetTypes) => {
     const basePath = repoInfo.directory
         ? `${repoInfo.directory}/${assetPath}`
         : assetPath;
     const fetchPromises = assetTypes.map((assetType) => fetchDirectoryContents(repoInfo, `${basePath}/${assetType}`, tag));
-    const results = await Promise.all(fetchPromises);
+    const rawResults = await Promise.all(fetchPromises);
+    const expandedResults = await Promise.all(rawResults.map((entries, index) => {
+        if (!entries)
+            return Promise.resolve([]);
+        const assetDirPath = `${basePath}/${assetTypes[index]}`;
+        return expandDirectoryEntries(repoInfo, assetDirPath, entries, tag);
+    }));
     const assetFiles = {};
     assetTypes.forEach((assetType, index) => {
-        assetFiles[assetType] = results[index] || [];
+        assetFiles[assetType] = expandedResults[index] || [];
     });
     return assetFiles;
 };
@@ -83,5 +110,6 @@ exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
 exports.downloadAssetFiles = downloadAssetFiles;
 exports.downloadFile = downloadFile;
+exports.expandDirectoryEntries = expandDirectoryEntries;
 exports.fetchAssetFiles = fetchAssetFiles;
 exports.fetchDirectoryContents = fetchDirectoryContents;

package/dist/core/github.d.ts

@@ -1,4 +1,4 @@
-import type { AssetType, GitHubEntry, GitHubRepoInfo } from '../utils/types';
+import type { AssetType, GitHubEntry, GitHubRepoInfo } from '../utils/types.js';
 /**
  * Error thrown when GitHub API rate limit is exceeded
  */
@@ -19,6 +19,19 @@ export declare class NotFoundError extends Error {
  * @returns Array of GitHubEntry or null if directory doesn't exist
  */
 export declare const fetchDirectoryContents: (repoInfo: GitHubRepoInfo, path: string, tag: string) => Promise<GitHubEntry[] | null>;
+/**
+ * Expand directory entries into flat file entries with recursive traversal.
+ * Fetches contents of each directory and prefixes file names with the directory path.
+ * Recursively traverses subdirectories to collect all nested files.
+ *
+ * @param repoInfo - GitHub repository information
+ * @param parentPath - Parent directory path in the repository
+ * @param entries - Array of GitHubEntry (may contain both file and dir types)
+ * @param tag - Git tag or ref to fetch from
+ * @param prefix - Accumulated path prefix for nested entries
+ * @returns Flat array of file GitHubEntry with dir-prefixed names
+ */
+export declare const expandDirectoryEntries: (repoInfo: GitHubRepoInfo, parentPath: string, entries: GitHubEntry[], tag: string, prefix?: string) => Promise<GitHubEntry[]>;
 /**
  * Fetch asset files dynamically from GitHub
  * @param repoInfo - GitHub repository information

package/dist/core/github.mjs

@@ -35,17 +35,44 @@ const fetchDirectoryContents = async (repoInfo, path, tag) => {
     if (!response.ok)
         throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
     const data = await response.json();
-    return data.filter((entry) => entry.type === 'file' && entry.name.endsWith('.md'));
+    return data.filter((entry) => (entry.type === 'file' && entry.name.endsWith('.md')) ||
+        entry.type === 'dir');
+};
+const expandDirectoryEntries = async (repoInfo, parentPath, entries, tag, prefix = '') => {
+    const result = [];
+    for (const entry of entries) {
+        const entryPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'file') {
+            result.push({
+                ...entry,
+                name: prefix ? entryPrefix : entry.name,
+            });
+        }
+        else if (entry.type === 'dir') {
+            const subEntries = await fetchDirectoryContents(repoInfo, `${parentPath}/${entry.name}`, tag);
+            if (subEntries) {
+                const expanded = await expandDirectoryEntries(repoInfo, `${parentPath}/${entry.name}`, subEntries, tag, entryPrefix);
+                result.push(...expanded);
+            }
+        }
+    }
+    return result;
 };
 const fetchAssetFiles = async (repoInfo, assetPath, tag, assetTypes) => {
     const basePath = repoInfo.directory
         ? `${repoInfo.directory}/${assetPath}`
         : assetPath;
     const fetchPromises = assetTypes.map((assetType) => fetchDirectoryContents(repoInfo, `${basePath}/${assetType}`, tag));
-    const results = await Promise.all(fetchPromises);
+    const rawResults = await Promise.all(fetchPromises);
+    const expandedResults = await Promise.all(rawResults.map((entries, index) => {
+        if (!entries)
+            return Promise.resolve([]);
+        const assetDirPath = `${basePath}/${assetTypes[index]}`;
+        return expandDirectoryEntries(repoInfo, assetDirPath, entries, tag);
+    }));
     const assetFiles = {};
     assetTypes.forEach((assetType, index) => {
-        assetFiles[assetType] = results[index] || [];
+        assetFiles[assetType] = expandedResults[index] || [];
     });
     return assetFiles;
 };
@@ -77,4 +104,4 @@ const downloadAssetFiles = async (repoInfo, assetPath, assetType, entries, tag)
     return results;
 };
 
-export { NotFoundError, RateLimitError, downloadAssetFiles, downloadFile, fetchAssetFiles, fetchDirectoryContents };
+export { NotFoundError, RateLimitError, downloadAssetFiles, downloadFile, expandDirectoryEntries, fetchAssetFiles, fetchDirectoryContents };

package/dist/core/migration.cjs

@@ -3,6 +3,7 @@
 var fs = require('node:fs');
 var path = require('node:path');
 var nameTransform = require('../utils/nameTransform.cjs');
+var packageName = require('../utils/packageName.cjs');
 var filesystem = require('./filesystem.cjs');
 var syncMeta = require('./syncMeta.cjs');
 
@@ -62,8 +63,8 @@ async function migrateToFlat(cwd, options = {}) {
                 });
                 for (const packageDir of packageDirs) {
                     const packagePath = path.join(scopePath, packageDir);
-                    const packageName = `${scopeDir}/${packageDir}`;
-                    console.log(`  📦 Processing ${packageName}...`);
+                    const packageName$1 = `${scopeDir}/${packageDir}`;
+                    console.log(`  📦 Processing ${packageName$1}...`);
                     try {
                         const metaPath = path.join(packagePath, '.sync-meta.json');
                         let legacyMeta = null;
@@ -75,7 +76,7 @@ async function migrateToFlat(cwd, options = {}) {
                             console.log(`    ⚠️  No .sync-meta.json found, skipping`);
                             continue;
                         }
-                        const prefix = nameTransform.packageNameToPrefix(packageName);
+                        const prefix = packageName.packageNameToPrefix(packageName$1);
                         const commandFiles = [];
                         const fileMappings = [];
                         for (const fileName of legacyMeta.files) {
@@ -112,7 +113,7 @@ async function migrateToFlat(cwd, options = {}) {
                             }
                         }
                         const packageInfo = {
-                            originalName: packageName,
+                            originalName: packageName$1,
                             version: legacyMeta.version,
                             files: {
                                 commands: assetType === 'commands' ? commandFiles : [],
@@ -136,11 +137,11 @@ async function migrateToFlat(cwd, options = {}) {
                             }
                         }
                         unifiedMeta = syncMeta.updatePackageInMeta(unifiedMeta, prefix, packageInfo);
-                        migratedPackages.push(packageName);
+                        migratedPackages.push(packageName$1);
                         legacyDirs.push(packagePath);
                     }
                     catch (error) {
-                        const errorMsg = `Failed to migrate ${packageName}: ${error}`;
+                        const errorMsg = `Failed to migrate ${packageName$1}: ${error}`;
                         console.error(`    ❌ ${errorMsg}`);
                         errors.push(errorMsg);
                     }

package/dist/core/migration.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, statSync, readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { packageNameToPrefix, toFlatFileName } from '../utils/nameTransform.mjs';
+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';
 

package/dist/core/packageScanner.cjs

@@ -72,15 +72,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);
                 }
@@ -100,7 +110,8 @@ 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) {
                 children.push({
                     id: relativePath,
@@ -139,36 +150,37 @@ 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}`;
                 children.push({
                     id: skillPath,
-                    label: name,
+                    label: entry.name,
                     path: skillPath,
                     type: 'skill-directory',
                     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 +197,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);
@@ -256,4 +260,5 @@ function searchPackagesRecursively(dir, packageName) {
     return null;
 }
 
+exports.isDirectorySkill = isDirectorySkill;
 exports.scanPackageAssets = scanPackageAssets;

package/dist/core/packageScanner.mjs

@@ -70,15 +70,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);
                 }
@@ -98,7 +108,8 @@ 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) {
                 children.push({
                     id: relativePath,
@@ -137,36 +148,37 @@ 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}`;
                 children.push({
                     id: skillPath,
-                    label: name,
+                    label: entry.name,
                     path: skillPath,
                     type: 'skill-directory',
                     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 +195,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);
@@ -254,4 +258,4 @@ function searchPackagesRecursively(dir, packageName) {
     return null;
 }
 
-export { scanPackageAssets };
+export { isDirectorySkill, scanPackageAssets };