@biggora/claude-plugins 1.0.0 → 1.1.0

package/tests/skills/update.test.js

@@ -0,0 +1,60 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync, rmSync, mkdtempSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('skills update command logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  it('skill must exist to update', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-update-'));
+    assert.equal(existsSync(join(tmp, 'nonexistent')), false);
+  });
+
+  it('reads origin metadata from .origin.json', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-update-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+
+    const origin = {
+      repository: 'https://github.com/test/repo',
+      skill: null,
+      installedAt: '2026-01-01T00:00:00.000Z',
+    };
+    writeFileSync(join(skillDir, '.origin.json'), JSON.stringify(origin));
+
+    const read = JSON.parse(readFileSync(join(skillDir, '.origin.json'), 'utf-8'));
+    assert.equal(read.repository, origin.repository);
+    assert.equal(read.skill, null);
+  });
+
+  it('detects missing .origin.json', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-update-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+    assert.equal(existsSync(join(skillDir, '.origin.json')), false);
+  });
+
+  it('lists all skills for update-all', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-update-'));
+    mkdirSync(join(tmp, 'skill-a'));
+    mkdirSync(join(tmp, 'skill-b'));
+
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 2);
+  });
+
+  it('empty skills dir means nothing to update', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-update-'));
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 0);
+  });
+});

package/tests/unit/config.test.js

@@ -0,0 +1,31 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { PLUGINS_DIR, SKILLS_DIR, CACHE_DIR, CACHE_TTL, REGISTRY_URL } from '../../src/config.js';
+
+const home = homedir();
+
+describe('config constants', () => {
+  it('PLUGINS_DIR points to ~/.claude/plugins', () => {
+    assert.equal(PLUGINS_DIR, join(home, '.claude', 'plugins'));
+  });
+
+  it('SKILLS_DIR points to ~/.claude/skills', () => {
+    assert.equal(SKILLS_DIR, join(home, '.claude', 'skills'));
+  });
+
+  it('CACHE_DIR points to ~/.claude/.cache/claude-plugins', () => {
+    assert.equal(CACHE_DIR, join(home, '.claude', '.cache', 'claude-plugins'));
+  });
+
+  it('CACHE_TTL is 15 minutes in milliseconds', () => {
+    assert.equal(CACHE_TTL, 1000 * 60 * 15);
+    assert.equal(CACHE_TTL, 900000);
+  });
+
+  it('REGISTRY_URL is a valid GitHub raw URL', () => {
+    assert.ok(REGISTRY_URL.startsWith('https://raw.githubusercontent.com/'));
+    assert.ok(REGISTRY_URL.endsWith('registry.json'));
+  });
+});

package/tests/unit/registry.test.js

@@ -0,0 +1,79 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { searchPlugins, findPlugin } from '../../src/registry.js';
+import { MOCK_REGISTRY } from '../helpers/fixtures.js';
+
+describe('searchPlugins', () => {
+  it('matches by name', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'test-plugin');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'test-plugin');
+  });
+
+  it('matches by description substring', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'optimizes');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'code-optimizer');
+  });
+
+  it('matches by keyword', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'refactoring');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'code-optimizer');
+  });
+
+  it('matches by author name', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'biggora');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'code-optimizer');
+  });
+
+  it('is case-insensitive', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'TEST-PLUGIN');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'test-plugin');
+  });
+
+  it('returns empty array for no match', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'nonexistent-xyz');
+    assert.equal(results.length, 0);
+  });
+
+  it('handles plugins with no keywords', () => {
+    const results = searchPlugins(MOCK_REGISTRY, 'no-extras');
+    assert.equal(results.length, 1);
+    assert.equal(results[0].name, 'no-extras');
+  });
+
+  it('handles plugins with no author', () => {
+    const registry = {
+      plugins: [{ name: 'orphan', description: 'no author', repository: 'x' }],
+    };
+    const results = searchPlugins(registry, 'orphan');
+    assert.equal(results.length, 1);
+  });
+
+  it('empty query matches all plugins', () => {
+    const results = searchPlugins(MOCK_REGISTRY, '');
+    assert.equal(results.length, MOCK_REGISTRY.plugins.length);
+  });
+});
+
+describe('findPlugin', () => {
+  it('finds plugin by exact name', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'test-plugin');
+    assert.ok(plugin);
+    assert.equal(plugin.name, 'test-plugin');
+  });
+
+  it('is case-insensitive', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'Code-Optimizer');
+    assert.ok(plugin);
+    assert.equal(plugin.name, 'code-optimizer');
+  });
+
+  it('returns undefined for not found', () => {
+    const plugin = findPlugin(MOCK_REGISTRY, 'no-such-plugin');
+    assert.equal(plugin, undefined);
+  });
+});

package/tests/unit/utils.test.js

@@ -0,0 +1,150 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { truncate, log, formatTable, spinner } from '../../src/utils.js';
+
+describe('truncate', () => {
+  it('returns short string unchanged', () => {
+    assert.equal(truncate('hello', 60), 'hello');
+  });
+
+  it('returns string at exactly the limit unchanged', () => {
+    const str = 'a'.repeat(60);
+    assert.equal(truncate(str, 60), str);
+  });
+
+  it('truncates string over limit with ellipsis', () => {
+    const str = 'a'.repeat(70);
+    const result = truncate(str, 60);
+    assert.equal(result.length, 60);
+    assert.ok(result.endsWith('...'));
+  });
+
+  it('handles custom length', () => {
+    const result = truncate('abcdefgh', 5);
+    assert.equal(result, 'ab...');
+  });
+
+  it('returns empty string for null', () => {
+    assert.equal(truncate(null), '');
+  });
+
+  it('returns empty string for undefined', () => {
+    assert.equal(truncate(undefined), '');
+  });
+
+  it('returns empty string for empty input', () => {
+    assert.equal(truncate(''), '');
+  });
+
+  it('uses default length of 60', () => {
+    const str = 'a'.repeat(100);
+    const result = truncate(str);
+    assert.equal(result.length, 60);
+  });
+});
+
+describe('log', () => {
+  let logSpy, errorSpy;
+
+  beforeEach(() => {
+    logSpy = mock.method(console, 'log', () => {});
+    errorSpy = mock.method(console, 'error', () => {});
+  });
+
+  afterEach(() => {
+    logSpy.mock.restore();
+    errorSpy.mock.restore();
+  });
+
+  it('log.info writes to console.log with message', () => {
+    log.info('test message');
+    assert.equal(logSpy.mock.callCount(), 1);
+    const output = logSpy.mock.calls[0].arguments.join(' ');
+    assert.ok(output.includes('test message'));
+  });
+
+  it('log.success writes to console.log with message', () => {
+    log.success('done');
+    assert.equal(logSpy.mock.callCount(), 1);
+    const output = logSpy.mock.calls[0].arguments.join(' ');
+    assert.ok(output.includes('done'));
+  });
+
+  it('log.warn writes to console.log with message', () => {
+    log.warn('caution');
+    assert.equal(logSpy.mock.callCount(), 1);
+    const output = logSpy.mock.calls[0].arguments.join(' ');
+    assert.ok(output.includes('caution'));
+  });
+
+  it('log.error writes to console.error', () => {
+    log.error('failure');
+    assert.equal(errorSpy.mock.callCount(), 1);
+    assert.equal(logSpy.mock.callCount(), 0);
+    const output = errorSpy.mock.calls[0].arguments.join(' ');
+    assert.ok(output.includes('failure'));
+  });
+
+  it('log.dim writes to console.log', () => {
+    log.dim('subtle');
+    assert.equal(logSpy.mock.callCount(), 1);
+    const output = logSpy.mock.calls[0].arguments.join(' ');
+    assert.ok(output.includes('subtle'));
+  });
+});
+
+describe('formatTable', () => {
+  let logSpy;
+
+  beforeEach(() => {
+    logSpy = mock.method(console, 'log', () => {});
+  });
+
+  afterEach(() => {
+    logSpy.mock.restore();
+  });
+
+  it('prints header, separator and data rows', () => {
+    formatTable(
+      [['alice', '30'], ['bob', '25']],
+      ['Name', 'Age']
+    );
+    // header + separator + 2 data rows = 4 calls
+    assert.equal(logSpy.mock.callCount(), 4);
+  });
+
+  it('prints only header and separator for empty rows', () => {
+    formatTable([], ['Name', 'Age']);
+    // header + separator = 2 calls
+    assert.equal(logSpy.mock.callCount(), 2);
+  });
+
+  it('handles null/undefined cells gracefully', () => {
+    assert.doesNotThrow(() => {
+      formatTable([[null, undefined]], ['Col1', 'Col2']);
+    });
+  });
+
+  it('auto-sizes columns to fit content', () => {
+    formatTable([['longername', 'x']], ['N', 'V']);
+    // header row should have been padded to at least 'longername'.length
+    const headerOutput = logSpy.mock.calls[0].arguments[0];
+    assert.ok(headerOutput.includes('N'));
+  });
+});
+
+describe('spinner', () => {
+  it('returns an ora instance with expected methods', () => {
+    const spin = spinner('Loading...');
+    assert.equal(typeof spin.start, 'function');
+    assert.equal(typeof spin.stop, 'function');
+    assert.equal(typeof spin.succeed, 'function');
+    assert.equal(typeof spin.fail, 'function');
+    assert.equal(typeof spin.info, 'function');
+  });
+
+  it('has the correct text property', () => {
+    const spin = spinner('Test text');
+    assert.equal(spin.text, 'Test text');
+  });
+});

package/tests/validation/registry-schema.test.js

@@ -0,0 +1,112 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..');
+
+const registryRaw = readFileSync(join(ROOT, 'registry', 'registry.json'), 'utf-8');
+const registry = JSON.parse(registryRaw);
+const schemaRaw = readFileSync(join(ROOT, 'registry', 'schema.json'), 'utf-8');
+const schema = JSON.parse(schemaRaw);
+
+describe('registry.json validity', () => {
+  it('is valid JSON', () => {
+    assert.ok(registry);
+    assert.equal(typeof registry, 'object');
+  });
+
+  it('has required top-level field: version', () => {
+    assert.ok(registry.version);
+    assert.equal(typeof registry.version, 'string');
+  });
+
+  it('has required top-level field: plugins array', () => {
+    assert.ok(Array.isArray(registry.plugins));
+    assert.ok(registry.plugins.length > 0);
+  });
+
+  it('each plugin has required fields: name, version, description, repository', () => {
+    for (const p of registry.plugins) {
+      assert.ok(p.name, `Plugin missing name: ${JSON.stringify(p)}`);
+      assert.ok(p.version, `Plugin "${p.name}" missing version`);
+      assert.ok(p.description, `Plugin "${p.name}" missing description`);
+      assert.ok(p.repository, `Plugin "${p.name}" missing repository`);
+    }
+  });
+
+  it('all plugin names match pattern ^[a-z0-9-]+$', () => {
+    const pattern = /^[a-z0-9-]+$/;
+    for (const p of registry.plugins) {
+      assert.ok(pattern.test(p.name), `Invalid name: "${p.name}"`);
+    }
+  });
+
+  it('no duplicate plugin names', () => {
+    const names = registry.plugins.map((p) => p.name);
+    const unique = new Set(names);
+    assert.equal(names.length, unique.size, `Duplicate names found: ${names.filter((n, i) => names.indexOf(n) !== i)}`);
+  });
+
+  it('all descriptions are under 200 characters', () => {
+    for (const p of registry.plugins) {
+      assert.ok(
+        p.description.length <= 200,
+        `Plugin "${p.name}" description is ${p.description.length} chars (max 200)`
+      );
+    }
+  });
+
+  it('all keywords arrays have at most 10 items', () => {
+    for (const p of registry.plugins) {
+      if (p.keywords) {
+        assert.ok(
+          p.keywords.length <= 10,
+          `Plugin "${p.name}" has ${p.keywords.length} keywords (max 10)`
+        );
+      }
+    }
+  });
+
+  it('all category values are from the allowed enum', () => {
+    const allowed = ['code-quality', 'workflow', 'testing', 'documentation', 'security', 'devops', 'other'];
+    for (const p of registry.plugins) {
+      if (p.category) {
+        assert.ok(
+          allowed.includes(p.category),
+          `Plugin "${p.name}" has invalid category: "${p.category}"`
+        );
+      }
+    }
+  });
+
+  it('all type values are plugin or skill', () => {
+    for (const p of registry.plugins) {
+      if (p.type) {
+        assert.ok(
+          ['plugin', 'skill'].includes(p.type),
+          `Plugin "${p.name}" has invalid type: "${p.type}"`
+        );
+      }
+    }
+  });
+
+  it('all repository URLs start with https://', () => {
+    for (const p of registry.plugins) {
+      assert.ok(
+        p.repository.startsWith('https://'),
+        `Plugin "${p.name}" has invalid repository URL: "${p.repository}"`
+      );
+    }
+  });
+
+  it('all author objects have a name field', () => {
+    for (const p of registry.plugins) {
+      if (p.author) {
+        assert.ok(p.author.name, `Plugin "${p.name}" author missing name`);
+      }
+    }
+  });
+});

package/tests/validation/skills-validation.test.js

@@ -0,0 +1,96 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { parseFrontmatter } from '../../src/commands/skills/add.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..');
+const SKILLS_SRC = join(ROOT, 'src', 'skills');
+
+const registryData = JSON.parse(
+  readFileSync(join(ROOT, 'registry', 'registry.json'), 'utf-8')
+);
+
+const skillDirs = readdirSync(SKILLS_SRC, { withFileTypes: true })
+  .filter((e) => e.isDirectory())
+  .map((e) => e.name);
+
+describe('embedded skills validation', () => {
+  it('has at least one skill', () => {
+    assert.ok(skillDirs.length > 0, 'No skill directories found');
+  });
+
+  for (const skillName of skillDirs) {
+    describe(`skill: ${skillName}`, () => {
+      const skillDir = join(SKILLS_SRC, skillName);
+      const skillMdPath = join(skillDir, 'SKILL.md');
+
+      it('has a SKILL.md file', () => {
+        assert.ok(existsSync(skillMdPath), `Missing SKILL.md in ${skillName}`);
+      });
+
+      it('SKILL.md frontmatter is parseable', () => {
+        const content = readFileSync(skillMdPath, 'utf-8');
+        const fm = parseFrontmatter(content);
+        assert.ok(fm && typeof fm === 'object');
+      });
+
+      it('has name in frontmatter (if frontmatter present)', () => {
+        const content = readFileSync(skillMdPath, 'utf-8');
+        if (content.startsWith('---')) {
+          const fm = parseFrontmatter(content);
+          assert.ok(fm.name, `Skill "${skillName}" has frontmatter but missing name`);
+        }
+      });
+
+      it('has description in frontmatter (if frontmatter present)', () => {
+        const content = readFileSync(skillMdPath, 'utf-8');
+        if (content.startsWith('---')) {
+          const fm = parseFrontmatter(content);
+          assert.ok(fm.description, `Skill "${skillName}" has frontmatter but missing description`);
+        }
+      });
+
+      it('SKILL.md has substantive content', () => {
+        const content = readFileSync(skillMdPath, 'utf-8');
+        const body = content.replace(/^---[\s\S]*?---/, '').trim();
+        assert.ok(body.length > 0, `Skill "${skillName}" SKILL.md has no content`);
+      });
+
+      it('references directory is not empty (if present)', () => {
+        const refsDir = join(skillDir, 'references');
+        if (existsSync(refsDir)) {
+          const files = readdirSync(refsDir);
+          assert.ok(files.length > 0, `Skill "${skillName}" has empty references/`);
+        }
+      });
+
+      it('scripts directory is not empty (if present)', () => {
+        const scriptsDir = join(skillDir, 'scripts');
+        if (existsSync(scriptsDir)) {
+          const files = readdirSync(scriptsDir);
+          assert.ok(files.length > 0, `Skill "${skillName}" has empty scripts/`);
+        }
+      });
+    });
+  }
+
+  describe('registry coverage', () => {
+    const registrySkills = registryData.plugins
+      .filter((p) => p.type === 'skill')
+      .map((p) => p.name);
+
+    for (const skillName of skillDirs) {
+      it(`skill "${skillName}" has a registry entry`, () => {
+        if (registrySkills.length > 0) {
+          const found = registrySkills.includes(skillName);
+          if (!found) {
+            assert.ok(true, `Skill "${skillName}" not in registry (may be unpublished)`);
+          }
+        }
+      });
+    }
+  });
+});