@biggora/claude-plugins 1.0.0 → 1.1.0

package/tests/commands/info.test.js

@@ -0,0 +1,49 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { findPlugin } from '../../src/registry.js';
+import { MOCK_REGISTRY } from '../helpers/fixtures.js';
+
+describe('info command logic', () => {
+  it('returns full plugin metadata when found', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'test-plugin');
+    assert.ok(plugin);
+    assert.equal(plugin.name, 'test-plugin');
+    assert.equal(plugin.version, '1.0.0');
+    assert.equal(plugin.description, 'A test plugin for unit tests');
+    assert.equal(plugin.author.name, 'tester');
+    assert.equal(plugin.license, 'MIT');
+    assert.equal(plugin.category, 'testing');
+    assert.equal(plugin.repository, 'https://github.com/test/test-plugin');
+  });
+
+  it('returns undefined for non-existent plugin', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'does-not-exist');
+    assert.equal(plugin, undefined);
+  });
+
+  it('handles plugin with missing optional fields', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'no-extras');
+    assert.ok(plugin);
+    assert.equal(plugin.author, undefined);
+    assert.equal(plugin.license, undefined);
+    assert.equal(plugin.category, undefined);
+    assert.equal(plugin.keywords, undefined);
+    assert.equal(plugin.commands, undefined);
+  });
+
+  it('plugin fields default correctly for display', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'no-extras');
+    // Mirror how info.js handles defaults
+    const author = plugin.author?.name || '-';
+    const license = plugin.license || '-';
+    const category = plugin.category || '-';
+    const keywords = (plugin.keywords || []).join(', ') || '-';
+    const commands = (plugin.commands || []).join(', ') || '-';
+
+    assert.equal(author, '-');
+    assert.equal(license, '-');
+    assert.equal(category, '-');
+    assert.equal(keywords, '-');
+    assert.equal(commands, '-');
+  });
+});

package/tests/commands/install.test.js

@@ -0,0 +1,36 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { findPlugin } from '../../src/registry.js';
+import { MOCK_REGISTRY } from '../helpers/fixtures.js';
+
+describe('install command logic', () => {
+  it('findPlugin returns plugin when found', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'test-plugin');
+    assert.ok(plugin);
+    assert.equal(plugin.name, 'test-plugin');
+    assert.equal(plugin.repository, 'https://github.com/test/test-plugin');
+  });
+
+  it('findPlugin returns undefined when not found', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'nonexistent');
+    assert.equal(plugin, undefined);
+  });
+
+  it('plugin repository URL is used for git clone', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'test-plugin');
+    const gitUrl = `${plugin.repository}.git`;
+    assert.equal(gitUrl, 'https://github.com/test/test-plugin.git');
+  });
+
+  it('plugin has commands array for post-install display', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'test-plugin');
+    assert.ok(Array.isArray(plugin.commands));
+    assert.equal(plugin.commands.length, 1);
+    assert.equal(plugin.commands[0], '/test');
+  });
+
+  it('plugin without commands has empty or undefined commands', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'no-extras');
+    assert.ok(!plugin.commands || plugin.commands.length === 0);
+  });
+});

package/tests/commands/list.test.js

@@ -0,0 +1,66 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync, mkdtempSync, readdirSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('list command logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  it('readdirSync returns empty for empty directory', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'list-test-'));
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 0);
+  });
+
+  it('detects plugin directories', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'list-test-'));
+    mkdirSync(join(tmp, 'plugin-a'));
+    mkdirSync(join(tmp, 'plugin-b'));
+    writeFileSync(join(tmp, 'not-a-dir.txt'), 'file');
+
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 2);
+  });
+
+  it('reads plugin manifest for version and description', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'list-test-'));
+    const pluginDir = join(tmp, 'my-plugin');
+    mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
+    writeFileSync(
+      join(pluginDir, '.claude-plugin', 'plugin.json'),
+      JSON.stringify({ name: 'my-plugin', version: '1.2.3', description: 'Test desc' })
+    );
+
+    const manifestPath = join(pluginDir, '.claude-plugin', 'plugin.json');
+    assert.ok(existsSync(manifestPath));
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    assert.equal(manifest.version, '1.2.3');
+    assert.equal(manifest.description, 'Test desc');
+  });
+
+  it('handles missing manifest gracefully', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'list-test-'));
+    mkdirSync(join(tmp, 'plugin-no-manifest'));
+    const manifestPath = join(tmp, 'plugin-no-manifest', '.claude-plugin', 'plugin.json');
+    assert.equal(existsSync(manifestPath), false);
+  });
+
+  it('handles invalid JSON in manifest', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'list-test-'));
+    const pluginDir = join(tmp, 'bad-json');
+    mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
+    writeFileSync(join(pluginDir, '.claude-plugin', 'plugin.json'), '{invalid json}');
+
+    assert.throws(() => {
+      JSON.parse(readFileSync(join(pluginDir, '.claude-plugin', 'plugin.json'), 'utf-8'));
+    });
+  });
+});

package/tests/commands/publish.test.js

@@ -0,0 +1,182 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync, rmSync, mkdtempSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { VALID_PLUGIN_MANIFEST } from '../helpers/fixtures.js';
+
+describe('publish command validation logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  function createPluginDir(manifest = VALID_PLUGIN_MANIFEST, includeReadme = true) {
+    tmp = mkdtempSync(join(tmpdir(), 'publish-test-'));
+    mkdirSync(join(tmp, '.claude-plugin'), { recursive: true });
+    writeFileSync(
+      join(tmp, '.claude-plugin', 'plugin.json'),
+      JSON.stringify(manifest, null, 2)
+    );
+    if (includeReadme) {
+      writeFileSync(join(tmp, 'README.md'), '# Test Plugin');
+    }
+    return tmp;
+  }
+
+  describe('required files', () => {
+    it('detects missing .claude-plugin/plugin.json', () => {
+      tmp = mkdtempSync(join(tmpdir(), 'publish-test-'));
+      writeFileSync(join(tmp, 'README.md'), '# Test');
+      assert.equal(existsSync(join(tmp, '.claude-plugin', 'plugin.json')), false);
+    });
+
+    it('detects missing README.md', () => {
+      tmp = mkdtempSync(join(tmpdir(), 'publish-test-'));
+      mkdirSync(join(tmp, '.claude-plugin'));
+      writeFileSync(join(tmp, '.claude-plugin', 'plugin.json'), '{}');
+      assert.equal(existsSync(join(tmp, 'README.md')), false);
+    });
+
+    it('validates both required files exist', () => {
+      const dir = createPluginDir();
+      assert.ok(existsSync(join(dir, '.claude-plugin', 'plugin.json')));
+      assert.ok(existsSync(join(dir, 'README.md')));
+    });
+  });
+
+  describe('manifest parsing', () => {
+    it('parses valid JSON', () => {
+      const dir = createPluginDir();
+      const manifest = JSON.parse(readFileSync(join(dir, '.claude-plugin', 'plugin.json'), 'utf-8'));
+      assert.equal(manifest.name, 'test-plugin');
+    });
+
+    it('detects invalid JSON', () => {
+      tmp = mkdtempSync(join(tmpdir(), 'publish-test-'));
+      mkdirSync(join(tmp, '.claude-plugin'));
+      writeFileSync(join(tmp, '.claude-plugin', 'plugin.json'), '{bad json}');
+      writeFileSync(join(tmp, 'README.md'), '# Test');
+
+      assert.throws(() => {
+        JSON.parse(readFileSync(join(tmp, '.claude-plugin', 'plugin.json'), 'utf-8'));
+      });
+    });
+  });
+
+  describe('required fields', () => {
+    it('validates name is present', () => {
+      const { name, ...noName } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noName.name, undefined);
+    });
+
+    it('validates version is present', () => {
+      const { version, ...noVersion } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noVersion.version, undefined);
+    });
+
+    it('validates description is present', () => {
+      const { description, ...noDesc } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noDesc.description, undefined);
+    });
+  });
+
+  describe('name validation pattern', () => {
+    const pattern = /^[a-z0-9-]+$/;
+
+    it('accepts valid names', () => {
+      assert.ok(pattern.test('my-plugin'));
+      assert.ok(pattern.test('plugin123'));
+      assert.ok(pattern.test('a-b-c'));
+      assert.ok(pattern.test('test'));
+    });
+
+    it('rejects names with uppercase', () => {
+      assert.equal(pattern.test('MyPlugin'), false);
+    });
+
+    it('rejects names with spaces', () => {
+      assert.equal(pattern.test('my plugin'), false);
+    });
+
+    it('rejects names with underscores', () => {
+      assert.equal(pattern.test('my_plugin'), false);
+    });
+
+    it('rejects names with special characters', () => {
+      assert.equal(pattern.test('my@plugin'), false);
+      assert.equal(pattern.test('my.plugin'), false);
+    });
+
+    it('rejects empty name', () => {
+      assert.equal(pattern.test(''), false);
+    });
+  });
+
+  describe('recommended fields (warnings)', () => {
+    it('detects missing repository', () => {
+      const { repository, ...noRepo } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noRepo.repository, undefined);
+    });
+
+    it('detects missing keywords', () => {
+      const { keywords, ...noKw } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noKw.keywords, undefined);
+    });
+
+    it('detects missing license', () => {
+      const { license, ...noLic } = VALID_PLUGIN_MANIFEST;
+      assert.equal(noLic.license, undefined);
+    });
+  });
+
+  describe('registry entry generation', () => {
+    it('generates correct entry structure', () => {
+      const manifest = VALID_PLUGIN_MANIFEST;
+      const repoUrl = manifest.repository || '';
+
+      const entry = {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        author: manifest.author || { name: 'unknown' },
+        repository: repoUrl.replace(/\.git$/, ''),
+        keywords: manifest.keywords || [],
+        license: manifest.license || 'MIT',
+        commands: manifest.commands || [],
+        category: manifest.category || 'other',
+      };
+
+      assert.equal(entry.name, 'test-plugin');
+      assert.equal(entry.version, '1.0.0');
+      assert.equal(entry.author.name, 'tester');
+      assert.equal(entry.repository, 'https://github.com/test/test-plugin');
+      assert.deepStrictEqual(entry.keywords, ['test']);
+    });
+
+    it('strips .git suffix from repository URL', () => {
+      const url = 'https://github.com/test/repo.git';
+      assert.equal(url.replace(/\.git$/, ''), 'https://github.com/test/repo');
+    });
+
+    it('defaults author to unknown when missing', () => {
+      const author = undefined;
+      const result = author || { name: 'unknown' };
+      assert.equal(result.name, 'unknown');
+    });
+
+    it('defaults category to other when missing', () => {
+      const category = undefined;
+      assert.equal(category || 'other', 'other');
+    });
+
+    it('defaults license to MIT when missing', () => {
+      const license = undefined;
+      assert.equal(license || 'MIT', 'MIT');
+    });
+  });
+});

package/tests/commands/search.test.js

@@ -0,0 +1,45 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { MOCK_REGISTRY } from '../helpers/fixtures.js';
+
+// We need to mock modules before importing the search command
+// Since mock.module() requires careful ordering, we test via CLI integration
+// For pure unit tests, we test the underlying functions directly
+
+import { searchPlugins } from '../../src/registry.js';
+
+describe('search command logic', () => {
+  let logSpy, errorSpy;
+
+  beforeEach(() => {
+    logSpy = mock.method(console, 'log', () => {});
+    errorSpy = mock.method(console, 'error', () => {});
+  });
+
+  afterEach(() => {
+    logSpy.mock.restore();
+    errorSpy.mock.restore();
+  });
+
+  it('lists all plugins when no query given', () => {
+    const results = searchPlugins(MOCK_REGISTRY, '');
+    assert.equal(results.length, MOCK_REGISTRY.plugins.length);
+  });
+
+  it('filters results with query', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'test');
+    assert.ok(results.length > 0);
+    assert.ok(results.length < MOCK_REGISTRY.plugins.length);
+  });
+
+  it('returns empty for no match', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'zzz-nonexistent');
+    assert.equal(results.length, 0);
+  });
+
+  it('search is case-insensitive', () => {
+    const r1 = searchPlugins(MOCK_REGISTRY, 'TEST');
+    const r2 = searchPlugins(MOCK_REGISTRY, 'test');
+    assert.equal(r1.length, r2.length);
+  });
+});

package/tests/commands/uninstall.test.js

@@ -0,0 +1,29 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, rmSync, mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('uninstall command logic', () => {
+  it('rmSync with recursive and force removes directory', () => {
+    const tmp = mkdtempSync(join(tmpdir(), 'uninstall-test-'));
+    const pluginDir = join(tmp, 'test-plugin');
+    mkdirSync(pluginDir);
+    assert.ok(existsSync(pluginDir));
+
+    rmSync(pluginDir, { recursive: true, force: true });
+    assert.ok(!existsSync(pluginDir));
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('rmSync with force does not throw for non-existent path', () => {
+    assert.doesNotThrow(() => {
+      rmSync(join(tmpdir(), 'nonexistent-' + Date.now()), { recursive: true, force: true });
+    });
+  });
+
+  it('existsSync returns false for non-existent plugin', () => {
+    assert.equal(existsSync(join(tmpdir(), 'no-such-plugin-' + Date.now())), false);
+  });
+});

package/tests/commands/update.test.js

@@ -0,0 +1,59 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, rmSync, mkdtempSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('update command logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  it('plugin must exist to update', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'update-test-'));
+    assert.equal(existsSync(join(tmp, 'nonexistent')), false);
+  });
+
+  it('detects if plugin has .git directory', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'update-test-'));
+    const pluginDir = join(tmp, 'my-plugin');
+    mkdirSync(pluginDir);
+    assert.equal(existsSync(join(pluginDir, '.git')), false);
+
+    mkdirSync(join(pluginDir, '.git'));
+    assert.equal(existsSync(join(pluginDir, '.git')), true);
+  });
+
+  it('lists all plugin directories for update-all', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'update-test-'));
+    mkdirSync(join(tmp, 'plugin-a'));
+    mkdirSync(join(tmp, 'plugin-b'));
+    mkdirSync(join(tmp, 'plugin-c'));
+
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 3);
+  });
+
+  it('empty plugins directory means nothing to update', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'update-test-'));
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 0);
+  });
+
+  it('git pull output containing "Already up to date" means no changes', () => {
+    const output = 'Already up to date.\n';
+    assert.ok(output.includes('Already up to date'));
+  });
+
+  it('counts updated plugins correctly', () => {
+    const results = [true, false, true, true, false];
+    const updated = results.filter(Boolean).length;
+    assert.equal(updated, 3);
+    assert.equal(`${updated}/${results.length}`, '3/5');
+  });
+});