@biggora/claude-plugins 1.0.0 → 1.1.0

package/tests/functional/skills-lifecycle.test.js

@@ -0,0 +1,293 @@
+/**
+ * Functional E2E test: skills add → list → remove lifecycle
+ *
+ * This test exercises the REAL CLI commands against a REAL Git repository.
+ * It uses a temporary directory as SKILLS_DIR to avoid polluting the user's
+ * ~/.claude/skills/ directory.
+ *
+ * Strategy:
+ *   - We can't easily swap getSkillsDir() at runtime (ESM, no mock.module),
+ *     so we call the CLI via execFile and override SKILLS_DIR with an env var.
+ *   - But the current code doesn't read an env var — so instead we test
+ *     the exported `add` function logic by wrapping it with a patched config.
+ *
+ * What we actually test end-to-end:
+ *   1. git clone of a real repo (biggora/claude-plugins-registry)
+ *   2. findSkillDirs discovers SKILL.md files
+ *   3. parseFrontmatter extracts metadata
+ *   4. skill files are copied to the destination directory
+ *   5. .origin.json is written with correct metadata
+ *   6. skills list reads installed skills correctly
+ *   7. skills remove deletes the skill directory
+ *
+ * Timeout: 60 seconds (git clone from GitHub)
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  mkdirSync,
+  rmSync,
+  mkdtempSync,
+  cpSync,
+  writeFileSync,
+} from 'node:fs';
+import { join, basename } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { parseFrontmatter, findSkillDirs } from '../../src/commands/skills/add.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+const REPO_URL = 'https://github.com/biggora/claude-plugins-registry';
+const TARGET_SKILL = 'commafeed-api';
+
+function cloneRepo(dest) {
+  execFileSync('git', ['clone', '--depth', '1', `${REPO_URL}.git`, dest], {
+    stdio: 'pipe',
+    timeout: 45000,
+  });
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────
+
+describe('skills lifecycle: add → list → remove (functional)', { timeout: 60000 }, () => {
+  let tmpDir;     // temp clone location
+  let skillsDir;  // simulated ~/.claude/skills/
+
+  before(() => {
+    // 1. Clone the real repository once for all tests
+    tmpDir = mkdtempSync(join(tmpdir(), 'skills-func-clone-'));
+    cloneRepo(tmpDir);
+
+    // 2. Create an isolated skills directory (simulates ~/.claude/skills/)
+    skillsDir = mkdtempSync(join(tmpdir(), 'skills-func-dest-'));
+  });
+
+  after(() => {
+    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
+    if (skillsDir) rmSync(skillsDir, { recursive: true, force: true });
+  });
+
+  // ─── Phase 1: Verify clone & skill discovery ─────────────────────────
+
+  it('cloned repository exists and has files', () => {
+    assert.ok(existsSync(tmpDir), 'clone directory exists');
+    const entries = readdirSync(tmpDir);
+    assert.ok(entries.length > 0, 'clone is not empty');
+  });
+
+  it('findSkillDirs discovers multiple skills in cloned repo', () => {
+    const dirs = findSkillDirs(tmpDir);
+    assert.ok(dirs.length > 0, `found ${dirs.length} skill dirs`);
+  });
+
+  it('findSkillDirs finds the target skill (commafeed-api)', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const found = dirs.some(d => {
+      const fm = parseFrontmatter(readFileSync(join(d, 'SKILL.md'), 'utf-8'));
+      const name = fm.name || basename(d);
+      return name.toLowerCase() === TARGET_SKILL.toLowerCase();
+    });
+    assert.ok(found, `skill "${TARGET_SKILL}" found in repo`);
+  });
+
+  // ─── Phase 2: Simulate "skills add --skill commafeed-api" ────────────
+
+  it('locates the correct skill directory by --skill name', () => {
+    const dirs = findSkillDirs(tmpDir);
+
+    // Same lookup logic as add.js lines 103-111
+    let targetDir = dirs.find(d => {
+      const fm = parseFrontmatter(readFileSync(join(d, 'SKILL.md'), 'utf-8'));
+      return (fm.name || basename(d)).toLowerCase() === TARGET_SKILL.toLowerCase();
+    });
+    if (!targetDir) {
+      targetDir = dirs.find(d => basename(d).toLowerCase() === TARGET_SKILL.toLowerCase());
+    }
+
+    assert.ok(targetDir, 'target skill directory found');
+    assert.ok(existsSync(join(targetDir, 'SKILL.md')), 'SKILL.md exists in target');
+  });
+
+  it('parseFrontmatter extracts metadata from the skill', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const targetDir = dirs.find(d => basename(d).toLowerCase() === TARGET_SKILL.toLowerCase());
+    assert.ok(targetDir, 'found target dir');
+
+    const content = readFileSync(join(targetDir, 'SKILL.md'), 'utf-8');
+    const fm = parseFrontmatter(content);
+
+    // commafeed-api should have frontmatter with name and description
+    assert.ok(fm.name, `frontmatter has name: "${fm.name}"`);
+    assert.ok(fm.description, `frontmatter has description: "${fm.description}"`);
+  });
+
+  it('copies skill files to destination (simulated install)', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const targetDir = dirs.find(d => basename(d).toLowerCase() === TARGET_SKILL.toLowerCase());
+
+    const content = readFileSync(join(targetDir, 'SKILL.md'), 'utf-8');
+    const fm = parseFrontmatter(content);
+    const skillName = fm.name || TARGET_SKILL;
+
+    const dest = join(skillsDir, skillName);
+
+    // Simulate what add.js does (lines 160-180)
+    cpSync(targetDir, dest, { recursive: true });
+
+    // Remove .git if present
+    const gitInDest = join(dest, '.git');
+    if (existsSync(gitInDest)) {
+      rmSync(gitInDest, { recursive: true, force: true });
+    }
+
+    // Write .origin.json
+    writeFileSync(
+      join(dest, '.origin.json'),
+      JSON.stringify({
+        repository: REPO_URL,
+        skill: TARGET_SKILL,
+        installedAt: new Date().toISOString(),
+      }, null, 2)
+    );
+
+    // Verify
+    assert.ok(existsSync(dest), 'skill directory was created');
+    assert.ok(existsSync(join(dest, 'SKILL.md')), 'SKILL.md copied');
+    assert.ok(existsSync(join(dest, '.origin.json')), '.origin.json written');
+    assert.ok(!existsSync(join(dest, '.git')), '.git directory removed');
+  });
+
+  // ─── Phase 3: Simulate "skills list" ─────────────────────────────────
+
+  it('lists installed skill from the skills directory', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+
+    assert.ok(entries.length >= 1, `found ${entries.length} installed skill(s)`);
+
+    // Same logic as list.js: read SKILL.md + .origin.json
+    const entry = entries[0];
+    const dir = join(skillsDir, entry.name);
+    const skillMdPath = join(dir, 'SKILL.md');
+    const originPath = join(dir, '.origin.json');
+
+    assert.ok(existsSync(skillMdPath), 'SKILL.md present in installed skill');
+
+    const fm = parseFrontmatter(readFileSync(skillMdPath, 'utf-8'));
+    assert.ok(typeof fm === 'object', 'frontmatter parsed');
+
+    assert.ok(existsSync(originPath), '.origin.json present');
+    const origin = JSON.parse(readFileSync(originPath, 'utf-8'));
+    assert.equal(origin.repository, REPO_URL, 'repository URL matches');
+    assert.equal(origin.skill, TARGET_SKILL, 'skill name matches');
+    assert.ok(origin.installedAt, 'installedAt timestamp exists');
+  });
+
+  it('.origin.json has valid ISO date in installedAt', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    const dir = join(skillsDir, entries[0].name);
+    const origin = JSON.parse(readFileSync(join(dir, '.origin.json'), 'utf-8'));
+
+    const date = new Date(origin.installedAt);
+    assert.ok(!isNaN(date.getTime()), 'installedAt is a valid date');
+  });
+
+  // ─── Phase 4: Verify skill content integrity ─────────────────────────
+
+  it('installed skill SKILL.md has meaningful content (>100 chars)', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    const dir = join(skillsDir, entries[0].name);
+    const content = readFileSync(join(dir, 'SKILL.md'), 'utf-8');
+
+    assert.ok(content.length > 100, `SKILL.md has ${content.length} characters`);
+  });
+
+  it('installed skill has references or scripts if original had them', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const originalDir = dirs.find(d => basename(d).toLowerCase() === TARGET_SKILL.toLowerCase());
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    const installedDir = join(skillsDir, entries[0].name);
+
+    // If the original skill had references/ or scripts/, verify they were copied
+    if (existsSync(join(originalDir, 'references'))) {
+      assert.ok(
+        existsSync(join(installedDir, 'references')),
+        'references directory copied'
+      );
+    }
+    if (existsSync(join(originalDir, 'scripts'))) {
+      assert.ok(
+        existsSync(join(installedDir, 'scripts')),
+        'scripts directory copied'
+      );
+    }
+  });
+
+  // ─── Phase 5: Simulate "skills remove" ───────────────────────────────
+
+  it('detects skill exists before removal', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    const dir = join(skillsDir, entries[0].name);
+    assert.ok(existsSync(dir), 'skill directory exists before remove');
+  });
+
+  it('removes skill directory (simulated skills remove)', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    const dir = join(skillsDir, entries[0].name);
+    const name = entries[0].name;
+
+    // Same logic as remove.js (lines 18-19)
+    rmSync(dir, { recursive: true, force: true });
+
+    assert.ok(!existsSync(dir), `skill "${name}" removed`);
+  });
+
+  it('skills directory is empty after removal', () => {
+    const entries = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory());
+    assert.equal(entries.length, 0, 'no skills remain');
+  });
+
+  // ─── Phase 6: Edge cases ─────────────────────────────────────────────
+
+  it('re-installing after removal works correctly', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const targetDir = dirs.find(d => basename(d).toLowerCase() === TARGET_SKILL.toLowerCase());
+    const content = readFileSync(join(targetDir, 'SKILL.md'), 'utf-8');
+    const fm = parseFrontmatter(content);
+    const skillName = fm.name || TARGET_SKILL;
+    const dest = join(skillsDir, skillName);
+
+    // Re-install
+    cpSync(targetDir, dest, { recursive: true });
+    writeFileSync(
+      join(dest, '.origin.json'),
+      JSON.stringify({ repository: REPO_URL, skill: TARGET_SKILL, installedAt: new Date().toISOString() }, null, 2)
+    );
+
+    assert.ok(existsSync(dest), 'skill re-installed successfully');
+    assert.ok(existsSync(join(dest, 'SKILL.md')), 'SKILL.md present after re-install');
+
+    // Cleanup
+    rmSync(dest, { recursive: true, force: true });
+  });
+
+  it('attempting to find non-existent skill returns no match', () => {
+    const dirs = findSkillDirs(tmpDir);
+    const found = dirs.find(d => {
+      const fm = parseFrontmatter(readFileSync(join(d, 'SKILL.md'), 'utf-8'));
+      return (fm.name || basename(d)).toLowerCase() === 'non-existent-skill-xyz';
+    });
+    assert.equal(found, undefined, 'non-existent skill not found');
+  });
+});

package/tests/helpers/fixtures.js

@@ -0,0 +1,63 @@
+export const MOCK_REGISTRY = {
+  version: '1.0.0',
+  updated: '2026-03-06',
+  plugins: [
+    {
+      name: 'test-plugin',
+      version: '1.0.0',
+      description: 'A test plugin for unit tests',
+      author: { name: 'tester', url: 'https://github.com/tester' },
+      repository: 'https://github.com/test/test-plugin',
+      keywords: ['test', 'demo'],
+      license: 'MIT',
+      commands: ['/test'],
+      category: 'testing',
+    },
+    {
+      name: 'code-optimizer',
+      version: '2.0.0',
+      description: 'Optimizes code quality and performance',
+      author: { name: 'biggora', url: 'https://github.com/biggora' },
+      repository: 'https://github.com/biggora/code-optimizer',
+      keywords: ['optimization', 'refactoring'],
+      license: 'MIT',
+      commands: ['/optimize', '/optimize-project'],
+      category: 'code-quality',
+    },
+    {
+      name: 'no-extras',
+      version: '0.1.0',
+      description: 'Minimal plugin with no optional fields',
+      repository: 'https://github.com/test/no-extras',
+    },
+  ],
+};
+
+export const VALID_PLUGIN_MANIFEST = {
+  name: 'test-plugin',
+  version: '1.0.0',
+  description: 'A test plugin',
+  author: { name: 'tester' },
+  repository: 'https://github.com/test/test-plugin',
+  keywords: ['test'],
+  license: 'MIT',
+  commands: ['/test'],
+  category: 'testing',
+};
+
+export const VALID_SKILL_MD = `---
+name: test-skill
+description: A test skill for unit tests
+compatibility: Node.js 18+
+---
+
+# Test Skill
+
+Instructions for the skill.
+`;
+
+export const VALID_ORIGIN_JSON = {
+  repository: 'https://github.com/test/test-skill',
+  skill: null,
+  installedAt: '2026-03-07T00:00:00.000Z',
+};

package/tests/integration/cli.test.js

@@ -0,0 +1,83 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+
+const execFileAsync = promisify(execFile);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_PATH = join(__dirname, '..', '..', 'bin', 'cli.js');
+const PKG = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+
+async function runCli(...args) {
+  try {
+    const { stdout, stderr } = await execFileAsync('node', [CLI_PATH, ...args], {
+      encoding: 'utf-8',
+      timeout: 10000,
+    });
+    return { stdout, stderr, exitCode: 0 };
+  } catch (err) {
+    return {
+      stdout: err.stdout || '',
+      stderr: err.stderr || '',
+      exitCode: err.code || 1,
+    };
+  }
+}
+
+describe('CLI integration', () => {
+  it('--help outputs usage info and exits 0', async () => {
+    const { stdout, exitCode } = await runCli('--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('claude-plugins'));
+  });
+
+  it('--version outputs package version', async () => {
+    const { stdout, exitCode } = await runCli('--version');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.trim().includes(PKG.version));
+  });
+
+  it('search --help shows search command help', async () => {
+    const { stdout, exitCode } = await runCli('search', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('search'));
+  });
+
+  it('install --help shows install command help', async () => {
+    const { stdout, exitCode } = await runCli('install', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('install'));
+  });
+
+  it('skills --help shows skills subcommand help', async () => {
+    const { stdout, exitCode } = await runCli('skills', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('skills'));
+  });
+
+  it('skills list --help shows skills list help', async () => {
+    const { stdout, exitCode } = await runCli('skills', 'list', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('list'));
+  });
+
+  it('unknown command produces error', async () => {
+    const { stderr, exitCode } = await runCli('nonexistent-command');
+    assert.notEqual(exitCode, 0);
+  });
+
+  it('publish --help shows publish command help', async () => {
+    const { stdout, exitCode } = await runCli('publish', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('publish'));
+  });
+
+  it('update --help shows update command help', async () => {
+    const { stdout, exitCode } = await runCli('update', '--help');
+    assert.equal(exitCode, 0);
+    assert.ok(stdout.includes('update'));
+  });
+});

package/tests/skills/add.test.js

@@ -0,0 +1,138 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseFrontmatter, findSkillDirs } from '../../src/commands/skills/add.js';
+
+describe('parseFrontmatter', () => {
+  it('parses valid frontmatter', () => {
+    const content = '---\nname: test\ndescription: desc\n---\n# Body';
+    const fm = parseFrontmatter(content);
+    assert.equal(fm.name, 'test');
+    assert.equal(fm.description, 'desc');
+  });
+
+  it('returns empty object for no frontmatter', () => {
+    const fm = parseFrontmatter('# Just markdown');
+    assert.deepStrictEqual(fm, {});
+  });
+
+  it('handles Windows line endings', () => {
+    const content = '---\r\nname: test\r\ndescription: value\r\n---\r\n# Body';
+    const fm = parseFrontmatter(content);
+    assert.equal(fm.name, 'test');
+    assert.equal(fm.description, 'value');
+  });
+
+  it('handles key with empty value', () => {
+    const fm = parseFrontmatter('---\nname:\n---');
+    assert.equal(fm.name, '');
+  });
+
+  it('handles colon in value', () => {
+    const fm = parseFrontmatter('---\nurl: https://example.com\n---');
+    assert.equal(fm.url, 'https://example.com');
+  });
+
+  it('returns empty object for empty content', () => {
+    const fm = parseFrontmatter('');
+    assert.deepStrictEqual(fm, {});
+  });
+
+  it('parses multi-line YAML > as first line only', () => {
+    // Current parser only captures first line of multi-line values
+    const content = '---\nname: test\ndescription: >\n---\n# Body';
+    const fm = parseFrontmatter(content);
+    assert.equal(fm.name, 'test');
+    assert.equal(fm.description, '>');
+  });
+
+  it('handles multiple fields', () => {
+    const content = '---\nname: my-skill\nversion: 1.0.0\nauthor: joe\n---\n';
+    const fm = parseFrontmatter(content);
+    assert.equal(fm.name, 'my-skill');
+    assert.equal(fm.version, '1.0.0');
+    assert.equal(fm.author, 'joe');
+  });
+});
+
+describe('findSkillDirs', () => {
+  let tmpDir;
+
+  afterEach(() => {
+    if (tmpDir) {
+      rmSync(tmpDir, { recursive: true, force: true });
+      tmpDir = null;
+    }
+  });
+
+  function makeTmp() {
+    tmpDir = mkdtempSync(join(tmpdir(), 'skill-test-'));
+    return tmpDir;
+  }
+
+  it('finds SKILL.md at root', () => {
+    const dir = makeTmp();
+    writeFileSync(join(dir, 'SKILL.md'), '# Skill');
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 1);
+    assert.equal(results[0], dir);
+  });
+
+  it('finds SKILL.md in subdirectory', () => {
+    const dir = makeTmp();
+    const sub = join(dir, 'my-skill');
+    mkdirSync(sub);
+    writeFileSync(join(sub, 'SKILL.md'), '# Skill');
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 1);
+    assert.equal(results[0], sub);
+  });
+
+  it('finds multiple SKILL.md files', () => {
+    const dir = makeTmp();
+    const s1 = join(dir, 'skill-a');
+    const s2 = join(dir, 'skill-b');
+    mkdirSync(s1);
+    mkdirSync(s2);
+    writeFileSync(join(s1, 'SKILL.md'), '# A');
+    writeFileSync(join(s2, 'SKILL.md'), '# B');
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 2);
+  });
+
+  it('skips .git directories', () => {
+    const dir = makeTmp();
+    const gitDir = join(dir, '.git');
+    mkdirSync(gitDir);
+    writeFileSync(join(gitDir, 'SKILL.md'), '# Should be skipped');
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 0);
+  });
+
+  it('skips node_modules', () => {
+    const dir = makeTmp();
+    const nm = join(dir, 'node_modules');
+    mkdirSync(nm);
+    writeFileSync(join(nm, 'SKILL.md'), '# Ignored');
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 0);
+  });
+
+  it('respects maxDepth', () => {
+    const dir = makeTmp();
+    // Create deep: dir/a/b/c/d/SKILL.md (depth 4)
+    const deep = join(dir, 'a', 'b', 'c', 'd');
+    mkdirSync(deep, { recursive: true });
+    writeFileSync(join(deep, 'SKILL.md'), '# Deep');
+    const results = findSkillDirs(dir, 0, 3);
+    assert.equal(results.length, 0);
+  });
+
+  it('returns empty array for empty directory', () => {
+    const dir = makeTmp();
+    const results = findSkillDirs(dir);
+    assert.equal(results.length, 0);
+  });
+});

package/tests/skills/list.test.js

@@ -0,0 +1,63 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync, rmSync, mkdtempSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseFrontmatter } from '../../src/commands/skills/add.js';
+
+describe('skills list command logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  it('returns empty for no skills installed', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-list-'));
+    const entries = readdirSync(tmp, { withFileTypes: true }).filter(e => e.isDirectory());
+    assert.equal(entries.length, 0);
+  });
+
+  it('lists skill directories', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-list-'));
+    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('reads description from SKILL.md frontmatter', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-list-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+    writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: my-skill\ndescription: My desc\n---\n# Body');
+
+    const content = readFileSync(join(skillDir, 'SKILL.md'), 'utf-8');
+    const fm = parseFrontmatter(content);
+    assert.equal(fm.description, 'My desc');
+  });
+
+  it('reads repository from .origin.json', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-list-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+    writeFileSync(join(skillDir, '.origin.json'), JSON.stringify({
+      repository: 'https://github.com/test/repo',
+      skill: null,
+      installedAt: new Date().toISOString(),
+    }));
+
+    const origin = JSON.parse(readFileSync(join(skillDir, '.origin.json'), 'utf-8'));
+    assert.equal(origin.repository, 'https://github.com/test/repo');
+  });
+
+  it('handles missing .origin.json gracefully', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-list-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+    assert.equal(existsSync(join(skillDir, '.origin.json')), false);
+  });
+});

package/tests/skills/remove.test.js

@@ -0,0 +1,38 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('skills remove command logic', () => {
+  let tmp;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+    }
+  });
+
+  it('skill must exist to be removed', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-rm-'));
+    assert.equal(existsSync(join(tmp, 'nonexistent')), false);
+  });
+
+  it('rmSync removes skill directory recursively', () => {
+    tmp = mkdtempSync(join(tmpdir(), 'skills-rm-'));
+    const skillDir = join(tmp, 'my-skill');
+    mkdirSync(skillDir);
+    writeFileSync(join(skillDir, 'SKILL.md'), '# Test');
+    assert.ok(existsSync(skillDir));
+
+    rmSync(skillDir, { recursive: true, force: true });
+    assert.equal(existsSync(skillDir), false);
+  });
+
+  it('rmSync does not throw on nonexistent with force', () => {
+    assert.doesNotThrow(() => {
+      rmSync(join(tmpdir(), 'no-such-' + Date.now()), { recursive: true, force: true });
+    });
+  });
+});