@emmraan/ai-skills 0.0.1 → 0.0.3

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

package/src/core/lockfile.ts

@@ -1,70 +1,70 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { dirname } from 'path';
-import { getLockfilePath } from './config.js';
-
-export interface LockfileEntry {
-  name: string;
-  version: string;
-  hash: string;
-  timestamp: string;
-  installPaths: string[];
-}
-
-export interface Lockfile {
-  version: 1;
-  installedSkills: Record<string, LockfileEntry>;
-}
-
-const INITIAL_LOCKFILE: Lockfile = {
-  version: 1,
-  installedSkills: {},
-};
-
-export async function readLockfile(): Promise<Lockfile> {
-  const path = getLockfilePath();
-  try {
-    const content = await readFile(path, 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return INITIAL_LOCKFILE;
-  }
-}
-
-export async function writeLockfile(lockfile: Lockfile): Promise<void> {
-  const path = getLockfilePath();
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, JSON.stringify(lockfile, null, 2), 'utf-8');
-}
-
-export async function addSkillToLockfile(
-  skillName: string,
-  version: string,
-  hash: string,
-  installPaths: string[]
-): Promise<void> {
-  const lockfile = await readLockfile();
-  lockfile.installedSkills[skillName] = {
-    name: skillName,
-    version,
-    hash,
-    timestamp: new Date().toISOString(),
-    installPaths,
-  };
-  await writeLockfile(lockfile);
-}
-
-export async function removeSkillFromLockfile(skillName: string): Promise<void> {
-  const lockfile = await readLockfile();
-  delete lockfile.installedSkills[skillName];
-  await writeLockfile(lockfile);
-}
-
-export async function getInstalledSkills(): Promise<LockfileEntry[]> {
-  const lockfile = await readLockfile();
-  return Object.values(lockfile.installedSkills);
-}
-
-export async function getSkillEntry(skillName: string): Promise<LockfileEntry | null> {
-  const lockfile = await readLockfile();
-  return lockfile.installedSkills[skillName] || null;
-}
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { getLockfilePath } from './config.js';
+
+export interface LockfileEntry {
+  name: string;
+  version: string;
+  hash: string;
+  timestamp: string;
+  installPaths: string[];
+}
+
+export interface Lockfile {
+  version: 1;
+  installedSkills: Record<string, LockfileEntry>;
+}
+
+const INITIAL_LOCKFILE: Lockfile = {
+  version: 1,
+  installedSkills: {},
+};
+
+export async function readLockfile(): Promise<Lockfile> {
+  const path = getLockfilePath();
+  try {
+    const content = await readFile(path, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return INITIAL_LOCKFILE;
+  }
+}
+
+export async function writeLockfile(lockfile: Lockfile): Promise<void> {
+  const path = getLockfilePath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(lockfile, null, 2), 'utf-8');
+}
+
+export async function addSkillToLockfile(
+  skillName: string,
+  version: string,
+  hash: string,
+  installPaths: string[]
+): Promise<void> {
+  const lockfile = await readLockfile();
+  lockfile.installedSkills[skillName] = {
+    name: skillName,
+    version,
+    hash,
+    timestamp: new Date().toISOString(),
+    installPaths,
+  };
+  await writeLockfile(lockfile);
+}
+
+export async function removeSkillFromLockfile(skillName: string): Promise<void> {
+  const lockfile = await readLockfile();
+  delete lockfile.installedSkills[skillName];
+  await writeLockfile(lockfile);
+}
+
+export async function getInstalledSkills(): Promise<LockfileEntry[]> {
+  const lockfile = await readLockfile();
+  return Object.values(lockfile.installedSkills);
+}
+
+export async function getSkillEntry(skillName: string): Promise<LockfileEntry | null> {
+  const lockfile = await readLockfile();
+  return lockfile.installedSkills[skillName] || null;
+}

package/src/index.ts

@@ -1,80 +1,80 @@
-import { install } from './commands/install.js';
-import { remove } from './commands/remove.js';
-import { list } from './commands/list.js';
-import { update } from './commands/update.js';
-import { generateLocal } from './commands/generate-local.js';
-import { error, info } from './utils/logger.js';
-
-const args = process.argv.slice(2);
-
-export async function main(): Promise<void> {
-  if (args.length === 0) {
-    showHelp();
-    return;
-  }
-
-  const command = args[0];
-
-  try {
-    if (command === 'install' && args.length >= 2) {
-      const skill = args[1];
-      const success = await install(skill);
-      process.exit(success ? 0 : 1);
-    } else if (command === 'remove' && args.length >= 2) {
-      const skill = args[1];
-      const success = await remove(skill);
-      process.exit(success ? 0 : 1);
-    } else if (command === 'list') {
-      const jsonFlag = args.includes('--json');
-      await list(jsonFlag);
-      process.exit(0);
-    } else if (command === 'update') {
-      const forceFlag = args.includes('--force');
-      let skillArg: string | undefined;
-      const skillIndex = args.indexOf('--skill');
-      if (skillIndex !== -1 && args.length > skillIndex + 1) {
-        skillArg = args[skillIndex + 1];
-      }
-      const success = await update({ force: forceFlag, skill: skillArg });
-      process.exit(success ? 0 : 1);
-    } else if (command === 'generate-local') {
-      const skillArg = args[1];
-      const success = await generateLocal(skillArg);
-      process.exit(success ? 0 : 1);
-    } else if (!command.startsWith('-')) {
-      // Default behavior: treat first arg as skill name to install
-      const success = await install(command);
-      process.exit(success ? 0 : 1);
-    } else {
-      showHelp();
-    }
-  } catch (err) {
-    error(`CLI error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
-}
-
-function showHelp() {
-  info(`
-AI Skills CLI - Install framework-agnostic SKILLS.md files
-
-Usage:
-  ai-skills <skill>              Install a skill
-  ai-skills install <skill>      Install a skill
-  ai-skills list [--json]        List installed and available skills
-  ai-skills remove <skill>       Remove an installed skill
-  ai-skills update [--force]     Update all installed skills
-                  [--skill <name>]   Update a specific skill
-  ai-skills generate-local [skill]    Run local backend generator
-
-Examples:
-  ai-skills react
-  ai-skills install typescript
-  ai-skills list
-  ai-skills remove python
-  ai-skills update --force
-  ai-skills update --skill react
-  ai-skills generate-local
-  ai-skills generate-local react
-  `);
-}
+import { install } from './commands/install.js';
+import { remove } from './commands/remove.js';
+import { list } from './commands/list.js';
+import { update } from './commands/update.js';
+import { generateLocal } from './commands/generate-local.js';
+import { error, info } from './utils/logger.js';
+
+const args = process.argv.slice(2);
+
+export async function main(): Promise<void> {
+  if (args.length === 0) {
+    showHelp();
+    return;
+  }
+
+  const command = args[0];
+
+  try {
+    if (command === 'install' && args.length >= 2) {
+      const skill = args[1];
+      const success = await install(skill);
+      process.exit(success ? 0 : 1);
+    } else if (command === 'remove' && args.length >= 2) {
+      const skill = args[1];
+      const success = await remove(skill);
+      process.exit(success ? 0 : 1);
+    } else if (command === 'list') {
+      const jsonFlag = args.includes('--json');
+      await list(jsonFlag);
+      process.exit(0);
+    } else if (command === 'update') {
+      const forceFlag = args.includes('--force');
+      let skillArg: string | undefined;
+      const skillIndex = args.indexOf('--skill');
+      if (skillIndex !== -1 && args.length > skillIndex + 1) {
+        skillArg = args[skillIndex + 1];
+      }
+      const success = await update({ force: forceFlag, skill: skillArg });
+      process.exit(success ? 0 : 1);
+    } else if (command === 'generate-local') {
+      const skillArg = args[1];
+      const success = await generateLocal(skillArg);
+      process.exit(success ? 0 : 1);
+    } else if (!command.startsWith('-')) {
+      // Default behavior: treat first arg as skill name to install
+      const success = await install(command);
+      process.exit(success ? 0 : 1);
+    } else {
+      showHelp();
+    }
+  } catch (err) {
+    error(`CLI error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  info(`
+AI Skills CLI - Install framework-agnostic SKILLS.md files
+
+Usage:
+  ai-skills <skill>              Install a skill
+  ai-skills install <skill>      Install a skill
+  ai-skills list [--json]        List installed and available skills
+  ai-skills remove <skill>       Remove an installed skill
+  ai-skills update [--force]     Update all installed skills
+                  [--skill <name>]   Update a specific skill
+  ai-skills generate-local [skill]    Run local backend generator
+
+Examples:
+  ai-skills react
+  ai-skills install typescript
+  ai-skills list
+  ai-skills remove python
+  ai-skills update --force
+  ai-skills update --skill react
+  ai-skills generate-local
+  ai-skills generate-local react
+  `);
+}

package/src/utils/__tests__/hash.test.ts

@@ -1,22 +1,22 @@
-import { describe, it, expect } from 'vitest';
-import { sha256 } from '../../utils/hash';
-
-describe('hash', () => {
-  it('should hash a string consistently', () => {
-    const content = 'test content';
-    const hash1 = sha256(content);
-    const hash2 = sha256(content);
-    expect(hash1).toBe(hash2);
-  });
-
-  it('should produce different hashes for different content', () => {
-    const hash1 = sha256('content1');
-    const hash2 = sha256('content2');
-    expect(hash1).not.toBe(hash2);
-  });
-
-  it('should produce valid sha256 hash (64 hex characters)', () => {
-    const hash = sha256('test');
-    expect(hash).toMatch(/^[a-f0-9]{64}$/);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { sha256 } from '../../utils/hash';
+
+describe('hash', () => {
+  it('should hash a string consistently', () => {
+    const content = 'test content';
+    const hash1 = sha256(content);
+    const hash2 = sha256(content);
+    expect(hash1).toBe(hash2);
+  });
+
+  it('should produce different hashes for different content', () => {
+    const hash1 = sha256('content1');
+    const hash2 = sha256('content2');
+    expect(hash1).not.toBe(hash2);
+  });
+
+  it('should produce valid sha256 hash (64 hex characters)', () => {
+    const hash = sha256('test');
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+});

package/src/utils/hash.ts

@@ -1,5 +1,5 @@
-import { createHash } from 'crypto';
-
-export function sha256(content: string): string {
-  return createHash('sha256').update(content).digest('hex');
-}
+import { createHash } from 'crypto';
+
+export function sha256(content: string): string {
+  return createHash('sha256').update(content).digest('hex');
+}

package/src/utils/logger.ts

@@ -1,21 +1,21 @@
-/* eslint-disable no-console */
-
-export function log(message: string) {
-  console.log(message);
-}
-
-export function info(message: string) {
-  console.log(`ℹ ${message}`);
-}
-
-export function success(message: string) {
-  console.log(`✓ ${message}`);
-}
-
-export function error(message: string) {
-  console.error(`✗ ${message}`);
-}
-
-export function warn(message: string) {
-  console.warn(`⚠ ${message}`);
-}
+/* eslint-disable no-console */
+
+export function log(message: string) {
+  console.log(message);
+}
+
+export function info(message: string) {
+  console.log(`ℹ ${message}`);
+}
+
+export function success(message: string) {
+  console.log(`✓ ${message}`);
+}
+
+export function error(message: string) {
+  console.error(`✗ ${message}`);
+}
+
+export function warn(message: string) {
+  console.warn(`⚠ ${message}`);
+}

package/src/utils/retry.ts

@@ -1,20 +1,20 @@
-export async function fetchWithRetry(url: string, maxRetries: number = 3): Promise<string> {
-  let lastError: Error | null = null;
-
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      return await response.text();
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (i < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1000));
-      }
-    }
-  }
-
-  throw lastError || new Error('Failed to fetch after retries');
-}
+export async function fetchWithRetry(url: string, maxRetries: number = 3): Promise<string> {
+  let lastError: Error | null = null;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.text();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (i < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1000));
+      }
+    }
+  }
+
+  throw lastError || new Error('Failed to fetch after retries');
+}

package/tsconfig.json

@@ -1,11 +1,11 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "types": ["node"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}