@botdocs/cli 0.3.1 → 0.3.2

package/dist/commands/publish.js

@@ -65,6 +65,11 @@ export async function publish(source, options) {
         console.error('Description is required. Use --description "..."');
         process.exit(1);
     }
+    // Pull type + sourceEcosystem from botdocs.json so the server stores
+    // the row as a SKILL/BUNDLE (instead of defaulting to SPEC).
+    const manifest = stat.isDirectory() ? readManifest(resolved) : null;
+    const botdocType = manifest?.type ?? 'SPEC';
+    const sourceEcosystem = manifest?.sourceEcosystem ?? null;
     console.log(`Publishing "${title}" (${files.length} file(s))...`);
     const result = await apiFetch('/api/botdocs', {
         method: 'POST',
@@ -76,6 +81,8 @@ export async function publish(source, options) {
             tags,
             license,
             files,
+            botdocType,
+            sourceEcosystem,
         },
     });
     if (options.json) {
@@ -85,6 +92,21 @@ export async function publish(source, options) {
         console.log(`\nPublished: ${result.url}`);
     }
 }
+function readManifest(source) {
+    const manifestPath = path.join(source, 'botdocs.json');
+    if (!fs.existsSync(manifestPath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        return parseManifest(raw);
+    }
+    catch {
+        // Validate is the canonical place to surface manifest errors; here we
+        // silently fall back so a malformed file doesn't break a publish that
+        // was already going to default to SPEC anyway.
+        return null;
+    }
+}
 async function maybeAutoCompile(source, options) {
     if (options.noCompile)
         return;
@@ -124,25 +146,38 @@ function collectFromFile(filePath) {
     return [{ filename, content, sortOrder: 0 }];
 }
 function collectFromDirectory(dirPath) {
-    const entries = fs.readdirSync(dirPath);
     const files = [];
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
+    walkDirectory(dirPath, dirPath, files);
+    files.sort((a, b) => a.sortOrder - b.sortOrder);
+    return files;
+}
+function walkDirectory(rootDir, currentDir, out) {
+    const entries = fs.readdirSync(currentDir);
+    for (const entry of entries) {
         if (entry.startsWith('.'))
             continue;
-        const fullPath = path.join(dirPath, entry);
+        const fullPath = path.join(currentDir, entry);
         const stat = fs.statSync(fullPath);
-        if (stat.isFile() && (entry.endsWith('.md') || entry.endsWith('.markdown'))) {
-            files.push({
-                filename: entry,
-                content: fs.readFileSync(fullPath, 'utf-8'),
-                sortOrder: entry === 'index.md' ? 0 : i + 1,
-            });
+        if (stat.isDirectory()) {
+            walkDirectory(rootDir, fullPath, out);
+            continue;
         }
+        if (!stat.isFile())
+            continue;
+        if (!entry.endsWith('.md') && !entry.endsWith('.markdown'))
+            continue;
+        // POSIX-style relative path so the install-time prefix check
+        // (e.g. `claude/SKILL.md`) works on every platform.
+        const relative = path
+            .relative(rootDir, fullPath)
+            .split(path.sep)
+            .join('/');
+        out.push({
+            filename: relative,
+            content: fs.readFileSync(fullPath, 'utf-8'),
+            sortOrder: relative === 'index.md' ? 0 : out.length + 1,
+        });
     }
-    // Ensure index.md is first
-    files.sort((a, b) => a.sortOrder - b.sortOrder);
-    return files;
 }
 function collectFromZip(zipPath) {
     const zip = new AdmZip(zipPath);
@@ -152,11 +187,13 @@ function collectFromZip(zipPath) {
         const entry = entries[i];
         if (entry.isDirectory)
             continue;
-        // Get the filename (strip any directory prefix)
-        const filename = path.basename(entry.entryName);
+        // POSIX-style path inside the archive — preserves directory prefixes
+        // (e.g. `claude/SKILL.md`) so install can route the file correctly.
+        const filename = entry.entryName.replace(/\\/g, '/');
+        const basename = path.basename(filename);
         if (!filename.endsWith('.md') && !filename.endsWith('.markdown'))
             continue;
-        if (filename.startsWith('.'))
+        if (basename.startsWith('.'))
             continue;
         files.push({
             filename,

package/dist/commands/publish.test.js

@@ -73,4 +73,66 @@ describe('publish auto-compile gate', () => {
         await publish(root, { description: 'desc' });
         expect(compileMod.compile).toHaveBeenCalledTimes(1);
     });
+    it('uploads nested files with directory-prefixed filenames', async () => {
+        // Build a tree with files in subdirectories — we need to know what
+        // ends up in the POST body so install can route by the `claude/` /
+        // `claude-code/` prefix.
+        const root = path.join(tmp.dir, 'nested-skill');
+        fs.mkdirSync(path.join(root, 'claude'), { recursive: true });
+        fs.mkdirSync(path.join(root, 'claude-code', 'commands'), { recursive: true });
+        fs.writeFileSync(path.join(root, 'index.md'), '# Top\n\n' + 'a'.repeat(150));
+        fs.writeFileSync(path.join(root, 'claude', 'SKILL.md'), '# Claude content');
+        fs.writeFileSync(path.join(root, 'claude-code', 'commands', 'cli.md'), '# CC content');
+        const fm = mockFetch([
+            {
+                method: 'POST',
+                url: '/api/botdocs',
+                response: { body: { id: 'b1', slug: 'nested-skill', url: 'http://x/y' } },
+            },
+        ]);
+        restoreFetch = fm.restore;
+        await publish(root, { description: 'desc', noCompile: true });
+        const post = fm.calls.find((c) => c.url.includes('/api/botdocs') && c.method === 'POST');
+        const body = post?.body;
+        const filenames = (body?.files ?? []).map((f) => f.filename).sort();
+        expect(filenames).toEqual([
+            'claude-code/commands/cli.md',
+            'claude/SKILL.md',
+            'index.md',
+        ]);
+    });
+    it('forwards botdocType + sourceEcosystem from botdocs.json', async () => {
+        const root = setupCanonicalSkill();
+        const fm = mockFetch([
+            {
+                method: 'POST',
+                url: '/api/botdocs',
+                response: { body: { id: 'b1', slug: 'my-skill', url: 'http://x/y' } },
+            },
+        ]);
+        restoreFetch = fm.restore;
+        await publish(root, { description: 'desc', noCompile: true });
+        const post = fm.calls.find((c) => c.url.includes('/api/botdocs') && c.method === 'POST');
+        const body = post?.body;
+        expect(body.botdocType).toBe('SKILL');
+        expect(body.sourceEcosystem).toBe('claude-code');
+    });
+    it('defaults to SPEC when no botdocs.json is present', async () => {
+        const root = path.join(tmp.dir, 'plain-spec');
+        fs.mkdirSync(root, { recursive: true });
+        fs.writeFileSync(path.join(root, 'index.md'), '# Spec\n\n' + 'a'.repeat(150));
+        const fm = mockFetch([
+            {
+                method: 'POST',
+                url: '/api/botdocs',
+                response: { body: { id: 'b1', slug: 'plain-spec', url: 'http://x/y' } },
+            },
+        ]);
+        restoreFetch = fm.restore;
+        await publish(root, { description: 'desc' });
+        const post = fm.calls.find((c) => c.url.includes('/api/botdocs') && c.method === 'POST');
+        const body = post?.body;
+        expect(body.botdocType).toBe('SPEC');
+        expect(body.sourceEcosystem).toBeNull();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botdocs/cli",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "CLI for BotDocs — clone, search, publish, and endorse concept specifications.",
   "keywords": [
     "botdocs",