@emmraan/ai-skills 0.0.1 → 0.0.2

package/src/core/__tests__/downloader.test.ts

@@ -1,66 +1,66 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as downloader from '../../core/downloader';
-
-vi.mock('../../utils/retry', () => ({
-  fetchWithRetry: vi.fn(),
-}));
-
-describe('downloader', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should fetch registry index', async () => {
-    const { fetchWithRetry } = await import('../../utils/retry');
-    const mockIndex = {
-      skills: {
-        react: {
-          version: '18.2.0',
-          domains: ['frontend', 'ui'],
-          lastGenerated: '2026-02-06T00:00:00Z',
-        },
-      },
-    };
-
-    vi.mocked(fetchWithRetry).mockResolvedValue(JSON.stringify(mockIndex));
-
-    const result = await downloader.fetchRegistryIndex();
-    expect(result.skills.react).toBeDefined();
-    expect(result.skills.react.version).toBe('18.2.0');
-  });
-
-  it('should fetch skill markdown', async () => {
-    const { fetchWithRetry } = await import('../../utils/retry');
-    const mockContent = '# React Skill\n\nSome content';
-
-    vi.mocked(fetchWithRetry).mockResolvedValue(mockContent);
-
-    const result = await downloader.fetchSkill('react');
-    expect(result).toBe(mockContent);
-  });
-
-  it('should get available skills', async () => {
-    const { fetchWithRetry } = await import('../../utils/retry');
-    const mockIndex = {
-      skills: {
-        react: {
-          version: '18.2.0',
-          domains: ['frontend'],
-          lastGenerated: '2026-02-06T00:00:00Z',
-        },
-        vue: {
-          version: '3.4.0',
-          domains: ['frontend'],
-          lastGenerated: '2026-02-06T00:00:00Z',
-        },
-      },
-    };
-
-    vi.mocked(fetchWithRetry).mockResolvedValue(JSON.stringify(mockIndex));
-
-    const result = await downloader.getAvailableSkills();
-    expect(result).toContain('react');
-    expect(result).toContain('vue');
-    expect(result).toHaveLength(2);
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as downloader from '../../core/downloader';
+
+vi.mock('../../utils/retry', () => ({
+  fetchWithRetry: vi.fn(),
+}));
+
+describe('downloader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should fetch registry index', async () => {
+    const { fetchWithRetry } = await import('../../utils/retry');
+    const mockIndex = {
+      skills: {
+        react: {
+          version: '18.2.0',
+          domains: ['frontend', 'ui'],
+          lastGenerated: '2026-02-06T00:00:00Z',
+        },
+      },
+    };
+
+    vi.mocked(fetchWithRetry).mockResolvedValue(JSON.stringify(mockIndex));
+
+    const result = await downloader.fetchRegistryIndex();
+    expect(result.skills.react).toBeDefined();
+    expect(result.skills.react.version).toBe('18.2.0');
+  });
+
+  it('should fetch skill markdown', async () => {
+    const { fetchWithRetry } = await import('../../utils/retry');
+    const mockContent = '# React Skill\n\nSome content';
+
+    vi.mocked(fetchWithRetry).mockResolvedValue(mockContent);
+
+    const result = await downloader.fetchSkill('react');
+    expect(result).toBe(mockContent);
+  });
+
+  it('should get available skills', async () => {
+    const { fetchWithRetry } = await import('../../utils/retry');
+    const mockIndex = {
+      skills: {
+        react: {
+          version: '18.2.0',
+          domains: ['frontend'],
+          lastGenerated: '2026-02-06T00:00:00Z',
+        },
+        vue: {
+          version: '3.4.0',
+          domains: ['frontend'],
+          lastGenerated: '2026-02-06T00:00:00Z',
+        },
+      },
+    };
+
+    vi.mocked(fetchWithRetry).mockResolvedValue(JSON.stringify(mockIndex));
+
+    const result = await downloader.getAvailableSkills();
+    expect(result).toContain('react');
+    expect(result).toContain('vue');
+    expect(result).toHaveLength(2);
+  });
+});

package/src/core/__tests__/lockfile.test.ts

@@ -1,90 +1,90 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { rm } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import * as lockfile from '../../core/lockfile';
-
-const lockfilePath = join(tmpdir(), `test-skills-lock-${Date.now()}.json`);
-
-// Mock the config to use a temp directory
-vi.mock('../../core/config', () => ({
-  getLockfilePath: () => lockfilePath,
-}));
-
-describe('lockfile', () => {
-  beforeEach(async () => {
-    // Clear the lockfile before each test
-    try {
-      await rm(lockfilePath, { force: true });
-    } catch {
-      // File doesn't exist, that's fine
-    }
-  });
-
-  afterEach(async () => {
-    // Clean up after tests
-    try {
-      await rm(lockfilePath, { force: true });
-    } catch {
-      // File doesn't exist, that's fine
-    }
-  });
-
-  it('should read an empty lockfile as initial state', async () => {
-    const result = await lockfile.readLockfile();
-    expect(result.version).toBe(1);
-    expect(result.installedSkills).toEqual({});
-  });
-
-  it('should add a skill to lockfile', async () => {
-    const skillName = 'react';
-    const version = '18.2.0';
-    const hash = 'abc123';
-    const paths = ['/home/user/.agents/skills/react/SKILLS.md'];
-
-    await lockfile.addSkillToLockfile(skillName, version, hash, paths);
-
-    const result = await lockfile.readLockfile();
-    expect(result.installedSkills[skillName]).toBeDefined();
-    expect(result.installedSkills[skillName].version).toBe(version);
-    expect(result.installedSkills[skillName].hash).toBe(hash);
-  });
-
-  it('should remove a skill from lockfile', async () => {
-    const skillName = 'react';
-    await lockfile.addSkillToLockfile(skillName, '18.2.0', 'hash1', []);
-
-    let result = await lockfile.readLockfile();
-    expect(result.installedSkills[skillName]).toBeDefined();
-
-    await lockfile.removeSkillFromLockfile(skillName);
-
-    result = await lockfile.readLockfile();
-    expect(result.installedSkills[skillName]).toBeUndefined();
-  });
-
-  it('should get installed skills', async () => {
-    await lockfile.addSkillToLockfile('react', '18.2.0', 'hash1', []);
-    await lockfile.addSkillToLockfile('vue', '3.4.0', 'hash2', []);
-
-    const installed = await lockfile.getInstalledSkills();
-    expect(installed).toHaveLength(2);
-    expect(installed.map((s) => s.name)).toContain('react');
-    expect(installed.map((s) => s.name)).toContain('vue');
-  });
-
-  it('should get a specific skill entry', async () => {
-    const skillName = 'react';
-    const version = '18.2.0';
-    const hash = 'abc123';
-    const paths = ['/home/user/.agents/skills/react/SKILLS.md'];
-
-    await lockfile.addSkillToLockfile(skillName, version, hash, paths);
-
-    const entry = await lockfile.getSkillEntry(skillName);
-    expect(entry).not.toBeNull();
-    expect(entry?.name).toBe(skillName);
-    expect(entry?.version).toBe(version);
-    expect(entry?.hash).toBe(hash);
-  });
-});
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import * as lockfile from '../../core/lockfile';
+
+const lockfilePath = join(tmpdir(), `test-skills-lock-${Date.now()}.json`);
+
+// Mock the config to use a temp directory
+vi.mock('../../core/config', () => ({
+  getLockfilePath: () => lockfilePath,
+}));
+
+describe('lockfile', () => {
+  beforeEach(async () => {
+    // Clear the lockfile before each test
+    try {
+      await rm(lockfilePath, { force: true });
+    } catch {
+      // File doesn't exist, that's fine
+    }
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    try {
+      await rm(lockfilePath, { force: true });
+    } catch {
+      // File doesn't exist, that's fine
+    }
+  });
+
+  it('should read an empty lockfile as initial state', async () => {
+    const result = await lockfile.readLockfile();
+    expect(result.version).toBe(1);
+    expect(result.installedSkills).toEqual({});
+  });
+
+  it('should add a skill to lockfile', async () => {
+    const skillName = 'react';
+    const version = '18.2.0';
+    const hash = 'abc123';
+    const paths = ['/home/user/.agents/skills/react/SKILLS.md'];
+
+    await lockfile.addSkillToLockfile(skillName, version, hash, paths);
+
+    const result = await lockfile.readLockfile();
+    expect(result.installedSkills[skillName]).toBeDefined();
+    expect(result.installedSkills[skillName].version).toBe(version);
+    expect(result.installedSkills[skillName].hash).toBe(hash);
+  });
+
+  it('should remove a skill from lockfile', async () => {
+    const skillName = 'react';
+    await lockfile.addSkillToLockfile(skillName, '18.2.0', 'hash1', []);
+
+    let result = await lockfile.readLockfile();
+    expect(result.installedSkills[skillName]).toBeDefined();
+
+    await lockfile.removeSkillFromLockfile(skillName);
+
+    result = await lockfile.readLockfile();
+    expect(result.installedSkills[skillName]).toBeUndefined();
+  });
+
+  it('should get installed skills', async () => {
+    await lockfile.addSkillToLockfile('react', '18.2.0', 'hash1', []);
+    await lockfile.addSkillToLockfile('vue', '3.4.0', 'hash2', []);
+
+    const installed = await lockfile.getInstalledSkills();
+    expect(installed).toHaveLength(2);
+    expect(installed.map((s) => s.name)).toContain('react');
+    expect(installed.map((s) => s.name)).toContain('vue');
+  });
+
+  it('should get a specific skill entry', async () => {
+    const skillName = 'react';
+    const version = '18.2.0';
+    const hash = 'abc123';
+    const paths = ['/home/user/.agents/skills/react/SKILLS.md'];
+
+    await lockfile.addSkillToLockfile(skillName, version, hash, paths);
+
+    const entry = await lockfile.getSkillEntry(skillName);
+    expect(entry).not.toBeNull();
+    expect(entry?.name).toBe(skillName);
+    expect(entry?.version).toBe(version);
+    expect(entry?.hash).toBe(hash);
+  });
+});

package/src/core/config.ts

@@ -1,29 +1,29 @@
-import { homedir, platform } from 'os';
-import { join } from 'path';
-
-export const REGISTRY_URL =
-  'https://raw.githubusercontent.com/Emmraan/ai-skills/main/packages/skills-registry';
-
-export const REGISTRY_INDEX_URL = `${REGISTRY_URL}/skills/.index.json`;
-
-export const AGENT_PLATFORMS = ['.claude', '.gemini', '.vscode', '.opencode', '.codex', '.agents'];
-
-export function getAgentPlatformDirs(): string[] {
-  const home = homedir();
-  return AGENT_PLATFORMS.map((p) => join(home, p, 'skills'));
-}
-
-export function getLockfilePath(): string {
-  const home = homedir();
-  return join(home, '.ai-skills', '.skill-lock.json');
-}
-
-export function getSkillInstallPaths(skillName: string): string[] {
-  return getAgentPlatformDirs().map((dir) => join(dir, skillName, 'SKILLS.md'));
-}
-
-export function getSkillMetadataPaths(skillName: string): string[] {
-  return getAgentPlatformDirs().map((dir) => join(dir, skillName, '.skill-metadata.json'));
-}
-
-export const IS_WINDOWS = platform() === 'win32';
+import { homedir, platform } from 'os';
+import { join } from 'path';
+
+export const REGISTRY_URL =
+  'https://raw.githubusercontent.com/Emmraan/ai-skills/main/packages/skills-registry';
+
+export const REGISTRY_INDEX_URL = `${REGISTRY_URL}/skills/.index.json`;
+
+export const AGENT_PLATFORMS = ['.claude', '.gemini', '.vscode', '.opencode', '.codex', '.agents'];
+
+export function getAgentPlatformDirs(): string[] {
+  const home = homedir();
+  return AGENT_PLATFORMS.map((p) => join(home, p, 'skills'));
+}
+
+export function getLockfilePath(): string {
+  const home = homedir();
+  return join(home, '.ai-skills', '.skill-lock.json');
+}
+
+export function getSkillInstallPaths(skillName: string): string[] {
+  return getAgentPlatformDirs().map((dir) => join(dir, skillName, 'SKILLS.md'));
+}
+
+export function getSkillMetadataPaths(skillName: string): string[] {
+  return getAgentPlatformDirs().map((dir) => join(dir, skillName, '.skill-metadata.json'));
+}
+
+export const IS_WINDOWS = platform() === 'win32';

package/src/core/downloader.ts

@@ -1,27 +1,27 @@
-import { REGISTRY_INDEX_URL, REGISTRY_URL } from './config.js';
-import { fetchWithRetry } from '../utils/retry.js';
-
-export interface SkillIndexEntry {
-  version: string;
-  domains: string[];
-  lastGenerated: string;
-}
-
-export interface SkillIndex {
-  skills: Record<string, SkillIndexEntry>;
-}
-
-export async function fetchRegistryIndex(): Promise<SkillIndex> {
-  const content = await fetchWithRetry(REGISTRY_INDEX_URL);
-  return JSON.parse(content);
-}
-
-export async function fetchSkill(skillName: string): Promise<string> {
-  const url = `${REGISTRY_URL}/skills/${skillName}/SKILLS.md`;
-  return fetchWithRetry(url);
-}
-
-export async function getAvailableSkills(): Promise<string[]> {
-  const index = await fetchRegistryIndex();
-  return Object.keys(index.skills);
-}
+import { REGISTRY_INDEX_URL, REGISTRY_URL } from './config.js';
+import { fetchWithRetry } from '../utils/retry.js';
+
+export interface SkillIndexEntry {
+  version: string;
+  domains: string[];
+  lastGenerated: string;
+}
+
+export interface SkillIndex {
+  skills: Record<string, SkillIndexEntry>;
+}
+
+export async function fetchRegistryIndex(): Promise<SkillIndex> {
+  const content = await fetchWithRetry(REGISTRY_INDEX_URL);
+  return JSON.parse(content);
+}
+
+export async function fetchSkill(skillName: string): Promise<string> {
+  const url = `${REGISTRY_URL}/skills/${skillName}/SKILLS.md`;
+  return fetchWithRetry(url);
+}
+
+export async function getAvailableSkills(): Promise<string[]> {
+  const index = await fetchRegistryIndex();
+  return Object.keys(index.skills);
+}

package/src/core/installer.ts

@@ -1,101 +1,101 @@
-import { writeFile, mkdir, readFile, rm } from 'fs/promises';
-import { dirname } from 'path';
-import { getSkillInstallPaths, getSkillMetadataPaths } from './config.js';
-import { sha256 } from '../utils/hash.js';
-import { info, warn } from '../utils/logger.js';
-
-export async function installSkill(skillName: string, skillContent: string): Promise<string[]> {
-  const installPaths = getSkillInstallPaths(skillName);
-  const metadataPaths = getSkillMetadataPaths(skillName);
-  const installedPaths: string[] = [];
-  const installedMetadataPaths: string[] = [];
-  const hash = sha256(skillContent);
-  const installedAt = new Date().toISOString();
-
-  for (let i = 0; i < installPaths.length; i++) {
-    const skillPath = installPaths[i];
-    const metadataPath = metadataPaths[i];
-    try {
-      const dir = dirname(skillPath);
-      await mkdir(dir, { recursive: true });
-      await writeFile(skillPath, skillContent, 'utf-8');
-      await writeFile(
-        metadataPath,
-        JSON.stringify(
-          {
-            skill: skillName,
-            hash,
-            installedAt,
-            file: 'SKILLS.md',
-          },
-          null,
-          2
-        ),
-        'utf-8'
-      );
-      installedPaths.push(skillPath);
-      installedMetadataPaths.push(metadataPath);
-      info(`Installed to ${skillPath}`);
-    } catch (err) {
-      warn(
-        `Failed to install to ${skillPath}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-
-  if (installedMetadataPaths.length > 0) {
-    info(`Wrote metadata to ${installedMetadataPaths.length} location(s)`);
-  }
-
-  return installedPaths;
-}
-
-export async function removeSkill(skillName: string): Promise<string[]> {
-  const installPaths = getSkillInstallPaths(skillName);
-  const metadataPaths = getSkillMetadataPaths(skillName);
-  const removedPaths: string[] = [];
-
-  for (let i = 0; i < installPaths.length; i++) {
-    const skillPath = installPaths[i];
-    const metadataPath = metadataPaths[i];
-    try {
-      await rm(skillPath, { force: true });
-      await rm(metadataPath, { force: true });
-      removedPaths.push(skillPath);
-      info(`Removed ${skillPath}`);
-    } catch (err) {
-      warn(`Failed to remove ${skillPath}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  return removedPaths;
-}
-
-export async function skillExists(skillName: string): Promise<boolean> {
-  const installPaths = getSkillInstallPaths(skillName);
-
-  for (const skillPath of installPaths) {
-    try {
-      await readFile(skillPath, 'utf-8');
-      return true;
-    } catch {
-      // Continue checking other paths
-    }
-  }
-
-  return false;
-}
-
-export async function readSkill(skillName: string): Promise<string | null> {
-  const installPaths = getSkillInstallPaths(skillName);
-
-  for (const skillPath of installPaths) {
-    try {
-      return await readFile(skillPath, 'utf-8');
-    } catch {
-      // Continue checking other paths
-    }
-  }
-
-  return null;
-}
+import { writeFile, mkdir, readFile, rm } from 'fs/promises';
+import { dirname } from 'path';
+import { getSkillInstallPaths, getSkillMetadataPaths } from './config.js';
+import { sha256 } from '../utils/hash.js';
+import { info, warn } from '../utils/logger.js';
+
+export async function installSkill(skillName: string, skillContent: string): Promise<string[]> {
+  const installPaths = getSkillInstallPaths(skillName);
+  const metadataPaths = getSkillMetadataPaths(skillName);
+  const installedPaths: string[] = [];
+  const installedMetadataPaths: string[] = [];
+  const hash = sha256(skillContent);
+  const installedAt = new Date().toISOString();
+
+  for (let i = 0; i < installPaths.length; i++) {
+    const skillPath = installPaths[i];
+    const metadataPath = metadataPaths[i];
+    try {
+      const dir = dirname(skillPath);
+      await mkdir(dir, { recursive: true });
+      await writeFile(skillPath, skillContent, 'utf-8');
+      await writeFile(
+        metadataPath,
+        JSON.stringify(
+          {
+            skill: skillName,
+            hash,
+            installedAt,
+            file: 'SKILLS.md',
+          },
+          null,
+          2
+        ),
+        'utf-8'
+      );
+      installedPaths.push(skillPath);
+      installedMetadataPaths.push(metadataPath);
+      info(`Installed to ${skillPath}`);
+    } catch (err) {
+      warn(
+        `Failed to install to ${skillPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
+  if (installedMetadataPaths.length > 0) {
+    info(`Wrote metadata to ${installedMetadataPaths.length} location(s)`);
+  }
+
+  return installedPaths;
+}
+
+export async function removeSkill(skillName: string): Promise<string[]> {
+  const installPaths = getSkillInstallPaths(skillName);
+  const metadataPaths = getSkillMetadataPaths(skillName);
+  const removedPaths: string[] = [];
+
+  for (let i = 0; i < installPaths.length; i++) {
+    const skillPath = installPaths[i];
+    const metadataPath = metadataPaths[i];
+    try {
+      await rm(skillPath, { force: true });
+      await rm(metadataPath, { force: true });
+      removedPaths.push(skillPath);
+      info(`Removed ${skillPath}`);
+    } catch (err) {
+      warn(`Failed to remove ${skillPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return removedPaths;
+}
+
+export async function skillExists(skillName: string): Promise<boolean> {
+  const installPaths = getSkillInstallPaths(skillName);
+
+  for (const skillPath of installPaths) {
+    try {
+      await readFile(skillPath, 'utf-8');
+      return true;
+    } catch {
+      // Continue checking other paths
+    }
+  }
+
+  return false;
+}
+
+export async function readSkill(skillName: string): Promise<string | null> {
+  const installPaths = getSkillInstallPaths(skillName);
+
+  for (const skillPath of installPaths) {
+    try {
+      return await readFile(skillPath, 'utf-8');
+    } catch {
+      // Continue checking other paths
+    }
+  }
+
+  return null;
+}