@emmraan/ai-skills 0.0.1 → 0.0.3

package/src/commands/update.ts

@@ -1,69 +1,69 @@
-import { fetchSkill, fetchRegistryIndex } from '../core/downloader.js';
-import { installSkill } from '../core/installer.js';
-import { addSkillToLockfile, getInstalledSkills, getSkillEntry } from '../core/lockfile.js';
-import { sha256 } from '../utils/hash.js';
-import { error, success, info, warn } from '../utils/logger.js';
-
-export async function update(options: { force?: boolean; skill?: string } = {}): Promise<boolean> {
-  try {
-    const installed = await getInstalledSkills();
-    const index = await fetchRegistryIndex();
-
-    if (options.skill) {
-      // Update specific skill
-      const skillName = options.skill;
-      const entry = await getSkillEntry(skillName);
-
-      if (!entry) {
-        warn(`${skillName} is not installed`);
-        return false;
-      }
-
-      const skillContent = await fetchSkill(skillName);
-      const newHash = sha256(skillContent);
-
-      if (newHash === entry.hash && !options.force) {
-        info(`${skillName} is already up-to-date`);
-        return true;
-      }
-
-      info(`Updating ${skillName}...`);
-      const installPaths = await installSkill(skillName, skillContent);
-      const version = index.skills[skillName]?.version || 'unknown';
-      await addSkillToLockfile(skillName, version, newHash, installPaths);
-      success(`Updated ${skillName}`);
-      return true;
-    }
-
-    // Update all installed skills
-    let updateCount = 0;
-    for (const entry of installed) {
-      try {
-        const skillContent = await fetchSkill(entry.name);
-        const newHash = sha256(skillContent);
-
-        if (newHash === entry.hash && !options.force) {
-          info(`${entry.name} is already up-to-date`);
-          continue;
-        }
-
-        info(`Updating ${entry.name}...`);
-        const installPaths = await installSkill(entry.name, skillContent);
-        const version = index.skills[entry.name]?.version || 'unknown';
-        await addSkillToLockfile(entry.name, version, newHash, installPaths);
-        success(`Updated ${entry.name}`);
-        updateCount++;
-      } catch (err) {
-        error(
-          `Failed to update ${entry.name}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-
-    success(`Updated ${updateCount} skill(s)`);
-    return true;
-  } catch (err) {
-    error(`Update failed: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-}
+import { fetchSkill, fetchRegistryIndex } from '../core/downloader.js';
+import { installSkill } from '../core/installer.js';
+import { addSkillToLockfile, getInstalledSkills, getSkillEntry } from '../core/lockfile.js';
+import { sha256 } from '../utils/hash.js';
+import { error, success, info, warn } from '../utils/logger.js';
+
+export async function update(options: { force?: boolean; skill?: string } = {}): Promise<boolean> {
+  try {
+    const installed = await getInstalledSkills();
+    const index = await fetchRegistryIndex();
+
+    if (options.skill) {
+      // Update specific skill
+      const skillName = options.skill;
+      const entry = await getSkillEntry(skillName);
+
+      if (!entry) {
+        warn(`${skillName} is not installed`);
+        return false;
+      }
+
+      const skillContent = await fetchSkill(skillName);
+      const newHash = sha256(skillContent);
+
+      if (newHash === entry.hash && !options.force) {
+        info(`${skillName} is already up-to-date`);
+        return true;
+      }
+
+      info(`Updating ${skillName}...`);
+      const installPaths = await installSkill(skillName, skillContent);
+      const version = index.skills[skillName]?.version || 'unknown';
+      await addSkillToLockfile(skillName, version, newHash, installPaths);
+      success(`Updated ${skillName}`);
+      return true;
+    }
+
+    // Update all installed skills
+    let updateCount = 0;
+    for (const entry of installed) {
+      try {
+        const skillContent = await fetchSkill(entry.name);
+        const newHash = sha256(skillContent);
+
+        if (newHash === entry.hash && !options.force) {
+          info(`${entry.name} is already up-to-date`);
+          continue;
+        }
+
+        info(`Updating ${entry.name}...`);
+        const installPaths = await installSkill(entry.name, skillContent);
+        const version = index.skills[entry.name]?.version || 'unknown';
+        await addSkillToLockfile(entry.name, version, newHash, installPaths);
+        success(`Updated ${entry.name}`);
+        updateCount++;
+      } catch (err) {
+        error(
+          `Failed to update ${entry.name}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+
+    success(`Updated ${updateCount} skill(s)`);
+    return true;
+  } catch (err) {
+    error(`Update failed: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}

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);
+}