@almyty/skills 1.0.11 → 1.0.14

package/dist/client.js

@@ -114,16 +114,82 @@ export class AlmytyClient {
     }
     async executeSkill(gatewayId, toolId, parameters) {
         // The execute endpoint expects a UUID. If toolId is a name slug,
-        // resolve it by listing the gateway's tools and matching.
+        // resolve by listing the gateway's tools and matching either
+        // the raw tool name, its kebab slug, OR the new
+        // `${gateway-slug}-${tool-slug}` composed form (with shared
+        // head segments deduped — the same rule the backend uses to
+        // generate SKILL.md names).
         const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
         let resolvedId = toolId;
         if (!uuidRegex.test(toolId)) {
-            const tools = await this.request(`/gateways/${gatewayId}/tools`);
-            const list = tools?.data?.gatewayTools || tools?.data?.data || tools?.data || [];
-            const match = (Array.isArray(list) ? list : []).find((gt) => {
+            const gateway = await this.request(`/gateways/${gatewayId}`).catch(() => null);
+            const gatewaySlug = gateway?.data?.endpoint?.replace(/^\/+/, '') || '';
+            // Walk every page — server caps limit at 100.
+            const allTools = [];
+            let page = 1;
+            while (true) {
+                const resp = await this.request(`/gateways/${gatewayId}/tools?limit=100&page=${page}`);
+                const data = resp?.data || resp;
+                const items = data?.gatewayTools || data?.data || (Array.isArray(data) ? data : []);
+                allTools.push(...(Array.isArray(items) ? items : []));
+                const totalPages = data?.totalPages ?? 1;
+                if (page >= totalPages || items.length === 0)
+                    break;
+                page++;
+                if (page > 50)
+                    break;
+            }
+            const slugify = (s) => (s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+            const dedupeShared = (head, tail) => {
+                const h = head.split('-').filter(Boolean);
+                const t = tail.split('-').filter(Boolean);
+                let i = 0;
+                while (i < t.length && i < h.length && t[i] === h[i])
+                    i++;
+                return t.slice(i).join('-');
+            };
+            // Mirror the server's skill-generator truncation when
+            // `${gateway}-${suffix}` exceeds 64 chars: drop kebab
+            // segments off the *head* of the suffix until the whole
+            // thing fits, falling back to a tail substring if a single
+            // segment is itself longer than the remaining budget. Cutting
+            // from the head keeps the unique tail of long method names
+            // (e.g. ~40 google-translate gRPC methods that all share a
+            // long prefix) addressable from the CLI.
+            const composeAndTruncate = (gw, suffix) => {
+                if (!gw)
+                    return suffix;
+                const combined = `${gw}-${suffix}`;
+                if (combined.length <= 64)
+                    return combined;
+                const room = 64 - gw.length - 1;
+                if (room <= 0)
+                    return gw.slice(0, 64);
+                const segments = suffix.split('-').filter(Boolean);
+                let trimmed = segments.join('-');
+                while (trimmed.length > room && segments.length > 1) {
+                    segments.shift();
+                    trimmed = segments.join('-');
+                }
+                if (trimmed.length > room)
+                    trimmed = trimmed.slice(-room);
+                return `${gw}-${trimmed.replace(/^-+|-+$/g, '')}`;
+            };
+            const match = allTools.find((gt) => {
                 const t = gt.tool || gt;
-                const slug = t.name?.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-                return slug === toolId || t.name === toolId;
+                if (!t)
+                    return false;
+                const rawName = t.name || '';
+                const slug = slugify(rawName);
+                const dedupedSuffix = dedupeShared(gatewaySlug, slug);
+                const composed = gatewaySlug
+                    ? `${gatewaySlug}-${dedupedSuffix}`
+                    : slug;
+                const truncated = composeAndTruncate(gatewaySlug, dedupedSuffix);
+                return (rawName === toolId ||
+                    slug === toolId ||
+                    composed === toolId ||
+                    truncated === toolId);
             });
             if (!match) {
                 throw new Error(`Tool "${toolId}" not found in gateway ${gatewayId}`);

package/dist/index.js

@@ -6,7 +6,7 @@ import { installSkills, removeSkills, listInstalledSkills } from './installer.js
 import { loadConfig, resolveTargets } from './config.js';
 import { generateMetaSkill } from './meta-skill.js';
 import { selectInstallTargetsAuto, selectInstallTargetsInteractive, } from './target-selector.js';
-const VERSION = '1.0.11';
+const VERSION = '1.0.12';
 function printHelp() {
     console.log(`
 almyty Skills CLI v${VERSION}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@almyty/skills",
-  "version": "1.0.11",
-  "description": "Install API skills into AI coding agents \u2014 Claude Code, Cursor, Windsurf, Copilot, Codex",
+  "version": "1.0.14",
+  "description": "Install API skills into AI coding agents — Claude Code, Cursor, Windsurf, Copilot, Codex",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -41,4 +41,4 @@
     "typescript": "^5.3.0",
     "vitest": "^4.1.0"
   }
-}
+}

package/dist/__tests__/client.test.d.ts

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

package/dist/__tests__/client.test.js

@@ -1,145 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { parseRef } from '../client.js';
-import { generateMetaSkill } from '../meta-skill.js';
-import { loadConfig } from '../config.js';
-// ---------------------------------------------------------------------------
-// parseRef()
-// ---------------------------------------------------------------------------
-describe('parseRef', () => {
-    it('parses @org/gateway as a gateway ref', () => {
-        const result = parseRef('@org/gateway');
-        expect(result).toEqual({
-            type: 'gateway',
-            orgSlug: 'org',
-            gatewaySlug: 'gateway',
-            raw: '@org/gateway',
-        });
-    });
-    it('parses @org/gateway/skill as a skill ref', () => {
-        const result = parseRef('@org/gateway/skill');
-        expect(result).toEqual({
-            type: 'skill',
-            orgSlug: 'org',
-            gatewaySlug: 'gateway',
-            skillName: 'skill',
-            raw: '@org/gateway/skill',
-        });
-    });
-    it('parses a UUID string as a uuid ref', () => {
-        const uuid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890';
-        const result = parseRef(uuid);
-        expect(result).toEqual({
-            type: 'uuid',
-            uuid,
-            raw: uuid,
-        });
-    });
-    it('parses uppercase UUID correctly', () => {
-        const uuid = 'A1B2C3D4-E5F6-7890-ABCD-EF1234567890';
-        const result = parseRef(uuid);
-        expect(result.type).toBe('uuid');
-        expect(result.uuid).toBe(uuid);
-    });
-    it('returns search for a random string', () => {
-        const result = parseRef('some-random-query');
-        expect(result).toEqual({
-            type: 'search',
-            raw: 'some-random-query',
-        });
-    });
-    it('returns search for an empty string', () => {
-        const result = parseRef('');
-        expect(result).toEqual({
-            type: 'search',
-            raw: '',
-        });
-    });
-    it('returns search for @ with only one segment', () => {
-        const result = parseRef('@org');
-        expect(result).toEqual({
-            type: 'search',
-            raw: '@org',
-        });
-    });
-    it('returns search for @ with more than three segments', () => {
-        const result = parseRef('@org/gw/skill/extra');
-        expect(result).toEqual({
-            type: 'search',
-            raw: '@org/gw/skill/extra',
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// generateMetaSkill()
-// ---------------------------------------------------------------------------
-describe('generateMetaSkill', () => {
-    it('returns a SkillFile with name "skills" and fileName "almyty-skills"', () => {
-        const skill = generateMetaSkill();
-        expect(skill.name).toBe('skills');
-        expect(skill.fileName).toBe('almyty-skills');
-    });
-    it('content includes npx @almyty/skills commands', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('npx @almyty/skills');
-    });
-    it('content references daemon command', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('daemon');
-    });
-    it('content references search command', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('search');
-    });
-    it('content references install command', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('install');
-    });
-    it('content references run command', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('run');
-    });
-    it('content includes SKILL.md front-matter', () => {
-        const { content } = generateMetaSkill();
-        expect(content).toContain('---');
-        expect(content).toContain('name: almyty-skills');
-        expect(content).toContain('description:');
-    });
-});
-// ---------------------------------------------------------------------------
-// loadConfig()
-// ---------------------------------------------------------------------------
-describe('loadConfig', () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        // Reset env between tests
-        process.env = { ...originalEnv };
-        delete process.env.APIFAI_SKILLS_DIR;
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-        vi.restoreAllMocks();
-    });
-    it('returns empty config when no .almytyrc exists and no env var', () => {
-        // Use a temp directory that definitely has no .almytyrc
-        const config = loadConfig('/tmp/nonexistent-dir-' + Date.now());
-        expect(config).toEqual({});
-    });
-    it('uses APIFAI_SKILLS_DIR env var when set', () => {
-        process.env.APIFAI_SKILLS_DIR = '/custom/skills/dir';
-        const config = loadConfig();
-        expect(config).toEqual({ skillsDir: '/custom/skills/dir' });
-    });
-    it('env var takes precedence over .almytyrc files', () => {
-        process.env.APIFAI_SKILLS_DIR = '/env/override';
-        // Even if we pass a projectDir, env should take priority
-        const config = loadConfig('/some/project');
-        expect(config.skillsDir).toBe('/env/override');
-    });
-    it('returns empty config for a directory with no rc file and no home rc', () => {
-        // Use a deeply nested temp path that certainly has no .almytyrc anywhere
-        // and also won't match ~/.almytyrc (already handled by the missing file)
-        const fakePath = `/tmp/almyty-test-${Date.now()}/deeply/nested/project`;
-        const config = loadConfig(fakePath);
-        expect(config).toEqual({});
-    });
-});