@agenthippo-ai/agenthippo 0.1.0

package/out/test/registry.test.js

@@ -0,0 +1,351 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ *  Tests for the local registry (JSON file-based).
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const registry_1 = require("../registry");
+suite('LocalRegistry', () => {
+    let tempDir;
+    let registry;
+    setup(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentide-registry-test-'));
+        const dbPath = path.join(tempDir, 'registry.json');
+        registry = new registry_1.LocalRegistry(dbPath);
+    });
+    teardown(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    suite('Pack operations', () => {
+        test('registers and retrieves a pack', async () => {
+            await registry.registerPack({
+                slug: 'test-pack',
+                displayName: 'Test Pack',
+                description: 'A test pack',
+                github: { owner: 'user', repo: 'test-pack' },
+                latestVersion: '1.0.0',
+                tags: ['test', 'demo'],
+                stats: { installs: 0, stars: 5 },
+            });
+            const pack = await registry.getPack('test-pack');
+            assert.ok(pack);
+            assert.strictEqual(pack.slug, 'test-pack');
+            assert.strictEqual(pack.displayName, 'Test Pack');
+            assert.ok(pack.tags.includes('test'));
+        });
+        test('returns null for nonexistent pack', async () => {
+            const pack = await registry.getPack('nonexistent');
+            assert.strictEqual(pack, null);
+        });
+        test('lists packs sorted by installs', async () => {
+            await registry.registerPack({
+                slug: 'popular',
+                displayName: 'Popular',
+                github: { owner: 'user', repo: 'popular' },
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 100, stars: 0 },
+            });
+            await registry.registerPack({
+                slug: 'new',
+                displayName: 'New',
+                github: { owner: 'user', repo: 'new' },
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 5, stars: 0 },
+            });
+            const packs = await registry.listPacks();
+            assert.strictEqual(packs.length, 2);
+            assert.strictEqual(packs[0].slug, 'popular');
+            assert.strictEqual(packs[1].slug, 'new');
+        });
+        test('tracks installs', async () => {
+            await registry.registerPack({
+                slug: 'tracked',
+                displayName: 'Tracked',
+                github: { owner: 'user', repo: 'tracked' },
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 0, stars: 0 },
+            });
+            await registry.trackPackInstall('tracked');
+            await registry.trackPackInstall('tracked');
+            const pack = await registry.getPack('tracked');
+            assert.ok(pack);
+            assert.strictEqual(pack.installs, 2);
+        });
+    });
+    suite('Skill operations', () => {
+        test('registers and retrieves a skill', async () => {
+            await registry.registerSkill({
+                slug: 'typescript-testing',
+                displayName: 'TypeScript Testing',
+                description: 'Vitest patterns',
+                github: { owner: 'user', repo: 'skills', path: 'typescript-testing' },
+                latestVersion: '1.0.0',
+                tags: ['typescript', 'testing'],
+                stats: { installs: 50 },
+            });
+            const skill = await registry.getSkill('typescript-testing');
+            assert.ok(skill);
+            assert.ok(skill.tags.includes('typescript'));
+        });
+        test('tracks agent packs the skill is installed to', async () => {
+            // Install skill to first pack
+            await registry.registerSkill({
+                slug: 'test-skill',
+                displayName: 'Test Skill',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'default',
+            });
+            let skill = await registry.getSkill('test-skill');
+            assert.ok(skill);
+            assert.ok(skill.installedTo.includes('default'));
+            // Install same skill to second pack (should merge)
+            await registry.registerSkill({
+                slug: 'test-skill',
+                displayName: 'Test Skill',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'code-reviewer',
+            });
+            skill = await registry.getSkill('test-skill');
+            assert.ok(skill);
+            assert.strictEqual(skill.installedTo.length, 2);
+            assert.ok(skill.installedTo.includes('default'));
+            assert.ok(skill.installedTo.includes('code-reviewer'));
+        });
+        test('checks if skill is installed to a specific pack', async () => {
+            await registry.registerSkill({
+                slug: 'check-skill',
+                displayName: 'Check Skill',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'my-pack',
+            });
+            const isInstalled = await registry.isSkillInstalledTo('check-skill', 'my-pack');
+            assert.strictEqual(isInstalled, true);
+            const notInstalled = await registry.isSkillInstalledTo('check-skill', 'other-pack');
+            assert.strictEqual(notInstalled, false);
+        });
+        test('unregisters skill from a pack', async () => {
+            await registry.registerSkill({
+                slug: 'unregister-skill',
+                displayName: 'Unregister Skill',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'pack-a',
+            });
+            await registry.registerSkill({
+                slug: 'unregister-skill',
+                displayName: 'Unregister Skill',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'pack-b',
+            });
+            // Unregister from pack-a
+            await registry.unregisterSkillFromPack('unregister-skill', 'pack-a');
+            const skill = await registry.getSkill('unregister-skill');
+            assert.ok(skill);
+            assert.strictEqual(skill.installedTo.length, 1);
+            assert.ok(!skill.installedTo.includes('pack-a'));
+            assert.ok(skill.installedTo.includes('pack-b'));
+        });
+    });
+    suite('MCP operations', () => {
+        test('registers and retrieves an MCP server', async () => {
+            await registry.registerMcp({
+                slug: 'github',
+                displayName: 'GitHub MCP',
+                description: 'GitHub API integration',
+                transport: 'stdio',
+                npmPackage: '@modelcontextprotocol/server-github',
+                latestVersion: '1.0.0',
+                tags: ['github', 'git'],
+                stats: { installs: 200 },
+            });
+            const mcp = await registry.getMcp('github');
+            assert.ok(mcp);
+            assert.strictEqual(mcp.transport, 'stdio');
+            assert.strictEqual(mcp.npmPackage, '@modelcontextprotocol/server-github');
+        });
+        test('tracks agent packs the MCP is installed to', async () => {
+            await registry.registerMcp({
+                slug: 'test-mcp',
+                displayName: 'Test MCP',
+                transport: 'stdio',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'default',
+            });
+            const mcp = await registry.getMcp('test-mcp');
+            assert.ok(mcp);
+            assert.ok(mcp.installedTo.includes('default'));
+        });
+        test('checks if MCP is installed to a specific pack', async () => {
+            await registry.registerMcp({
+                slug: 'check-mcp',
+                displayName: 'Check MCP',
+                transport: 'stdio',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'my-pack',
+            });
+            const isInstalled = await registry.isMcpInstalledTo('check-mcp', 'my-pack');
+            assert.strictEqual(isInstalled, true);
+            const notInstalled = await registry.isMcpInstalledTo('check-mcp', 'other-pack');
+            assert.strictEqual(notInstalled, false);
+        });
+        test('unregisters MCP from a pack', async () => {
+            await registry.registerMcp({
+                slug: 'unregister-mcp',
+                displayName: 'Unregister MCP',
+                transport: 'stdio',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'pack-a',
+            });
+            await registry.registerMcp({
+                slug: 'unregister-mcp',
+                displayName: 'Unregister MCP',
+                transport: 'stdio',
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 1 },
+                agentPackId: 'pack-b',
+            });
+            await registry.unregisterMcpFromPack('unregister-mcp', 'pack-a');
+            const mcp = await registry.getMcp('unregister-mcp');
+            assert.ok(mcp);
+            assert.strictEqual(mcp.installedTo.length, 1);
+            assert.ok(!mcp.installedTo.includes('pack-a'));
+            assert.ok(mcp.installedTo.includes('pack-b'));
+        });
+    });
+    suite('Search', () => {
+        setup(async () => {
+            // Seed some data
+            await registry.registerPack({
+                slug: 'typescript-dev',
+                displayName: 'TypeScript Development',
+                description: 'TypeScript development tools',
+                github: { owner: 'user', repo: 'ts-dev' },
+                latestVersion: '1.0.0',
+                tags: ['typescript', 'development'],
+                stats: { installs: 100, stars: 0 },
+            });
+            await registry.registerPack({
+                slug: 'react-components',
+                displayName: 'React Components',
+                description: 'React component library',
+                github: { owner: 'user', repo: 'react' },
+                latestVersion: '1.0.0',
+                tags: ['react', 'ui'],
+                stats: { installs: 50, stars: 0 },
+            });
+            await registry.registerSkill({
+                slug: 'typescript-testing',
+                displayName: 'TypeScript Testing',
+                description: 'Testing patterns',
+                github: { owner: 'user', repo: 'skills' },
+                latestVersion: '1.0.0',
+                tags: ['typescript', 'testing'],
+                stats: { installs: 30 },
+            });
+        });
+        test('searches across all types', async () => {
+            const results = await registry.search('typescript');
+            assert.ok(results.length > 0);
+            const types = results.map(r => r.type);
+            assert.ok(types.includes('pack'));
+            assert.ok(types.includes('skill'));
+        });
+        test('filters by type', async () => {
+            const results = await registry.search('typescript', { types: ['skill'] });
+            assert.ok(results.every(r => r.type === 'skill'));
+        });
+        test('limits results', async () => {
+            const results = await registry.search('typescript', { limit: 1 });
+            assert.strictEqual(results.length, 1);
+        });
+        test('ranks popular items higher', async () => {
+            const results = await registry.search('typescript');
+            const packIndex = results.findIndex(r => r.slug === 'typescript-dev');
+            const skillIndex = results.findIndex(r => r.slug === 'typescript-testing');
+            assert.ok(packIndex < skillIndex);
+        });
+        test('returns empty for no matches', async () => {
+            const results = await registry.search('nonexistent-query-xyz');
+            assert.strictEqual(results.length, 0);
+        });
+    });
+    suite('Persistence', () => {
+        test('persists data across instances', async () => {
+            const dbPath = path.join(tempDir, 'persist-test.json');
+            // First instance
+            const reg1 = new registry_1.LocalRegistry(dbPath);
+            await reg1.registerPack({
+                slug: 'persisted',
+                displayName: 'Persisted',
+                github: { owner: 'user', repo: 'persisted' },
+                latestVersion: '1.0.0',
+                tags: [],
+                stats: { installs: 0, stars: 0 },
+            });
+            // Second instance (fresh load)
+            const reg2 = new registry_1.LocalRegistry(dbPath);
+            const pack = await reg2.getPack('persisted');
+            assert.ok(pack);
+            assert.strictEqual(pack.slug, 'persisted');
+        });
+    });
+});