itismyskillmarket 1.3.3 → 1.3.5

package/README.md

@@ -1,6 +1,6 @@
 # SkillMarket
 
-Cross-platform skill manager for AI coding tools (Cursor, VSCode, Codex, OpenCode, Claude Code, Antigravity).
+Cross-platform skill manager for AI coding tools (Cursor, VSCode, Codex, OpenCode, Claude Code, Antigravity, OpenClaw, Hermes Agent).
 
 ## Installation
 
@@ -104,6 +104,8 @@ $ skm platforms
 OpenCode     ✅  Available (2 skills installed)
 Claude Code  ✅  Available (1 skills installed)
 VSCode       ✅  Available (0 skills installed)
+OpenClaw     ✅  Available
+Hermes Agent ✅  Available
 ```
 
 ## Development

package/dist/index.js

@@ -35,8 +35,12 @@ var PLATFORMS = [
   // OpenCode - 开源 AI 编程工具
   "claude",
   // Claude Code - Anthropic CLI 工具
-  "antigravity"
+  "antigravity",
   // Antigravity - AI 编程助手
+  "openclaw",
+  // OpenClaw - AgentSkills compatible agent
+  "hermes"
+  // Hermes Agent - NousResearch agent framework
 ];
 var REGISTRY_FILE = "registry.json";
 var LATEST_LINK = "latest";
@@ -555,15 +559,128 @@ var VSCodeAdapter = class extends BaseAdapter {
   }
 };
 
+// src/adapters/openclaw.ts
+import { readdirSync, existsSync, cpSync, rmSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { ensureDirSync } from "fs-extra";
+var OpenClawAdapter = class {
+  id = "openclaw";
+  name = "OpenClaw";
+  skillDir = join(homedir(), ".openclaw", "skills");
+  async isAvailable() {
+    try {
+      return existsSync(join(homedir(), ".openclaw"));
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    try {
+      const skillPath = join(this.skillDir, skillId);
+      return existsSync(skillPath);
+    } catch {
+      return false;
+    }
+  }
+  async install(skillId, sourceDir) {
+    ensureDirSync(this.skillDir);
+    const targetDir = join(this.skillDir, skillId);
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+    cpSync(sourceDir, targetDir, { recursive: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = join(this.skillDir, skillId);
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+  }
+  async listInstalled() {
+    try {
+      if (!existsSync(this.skillDir)) {
+        return [];
+      }
+      return readdirSync(this.skillDir).filter((name) => {
+        const fullPath = join(this.skillDir, name);
+        return existsSync(fullPath) && name !== ".";
+      });
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/hermes.ts
+import { readdirSync as readdirSync2, existsSync as existsSync2, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { ensureDirSync as ensureDirSync2 } from "fs-extra";
+var HermesAdapter = class {
+  id = "hermes";
+  name = "Hermes Agent";
+  skillDir = join2(homedir2(), ".hermes", "skills");
+  async isAvailable() {
+    try {
+      if (existsSync2(join2(homedir2(), ".hermes"))) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    try {
+      const skillPath = join2(this.skillDir, skillId);
+      return existsSync2(skillPath);
+    } catch {
+      return false;
+    }
+  }
+  async install(skillId, sourceDir) {
+    ensureDirSync2(this.skillDir);
+    const targetDir = join2(this.skillDir, skillId);
+    if (existsSync2(targetDir)) {
+      rmSync2(targetDir, { recursive: true, force: true });
+    }
+    cpSync2(sourceDir, targetDir, { recursive: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = join2(this.skillDir, skillId);
+    if (existsSync2(targetDir)) {
+      rmSync2(targetDir, { recursive: true, force: true });
+    }
+  }
+  async listInstalled() {
+    try {
+      if (!existsSync2(this.skillDir)) {
+        return [];
+      }
+      return readdirSync2(this.skillDir).filter((name) => {
+        const fullPath = join2(this.skillDir, name);
+        return existsSync2(fullPath) && name !== ".";
+      });
+    } catch {
+      return [];
+    }
+  }
+};
+
 // src/adapters/registry.ts
 var adapters = /* @__PURE__ */ new Map();
 function registerAdapters() {
   const opencode = new OpenCodeAdapter();
   const claude = new ClaudeAdapter();
   const vscode = new VSCodeAdapter();
+  const openclaw = new OpenClawAdapter();
+  const hermes = new HermesAdapter();
   adapters.set(opencode.id, opencode);
   adapters.set(claude.id, claude);
   adapters.set(vscode.id, vscode);
+  adapters.set(openclaw.id, openclaw);
+  adapters.set(hermes.id, hermes);
 }
 registerAdapters();
 async function detectPlatforms() {
@@ -575,6 +692,9 @@ async function detectPlatforms() {
   }
   return available;
 }
+function getAllAdapters() {
+  return Array.from(adapters.values());
+}
 function getAdapterByPlatform(platform) {
   const idMap = {
     opencode: "opencode",
@@ -584,8 +704,10 @@ function getAdapterByPlatform(platform) {
     // Cursor uses OpenCode-compatible structure
     codex: "opencode",
     // Codex uses OpenCode-compatible structure
-    antigravity: "opencode"
+    antigravity: "opencode",
     // Antigravity uses OpenCode-compatible structure
+    openclaw: "openclaw",
+    hermes: "hermes"
   };
   return adapters.get(idMap[platform]);
 }
@@ -1391,19 +1513,15 @@ var platformsCmd = program.command("platforms").description("Show available plat
 platformsCmd.action(async () => {
   try {
     const available = await detectPlatforms();
+    const allAdapters = getAllAdapters();
     console.log("\n\u{1F4CD} Available Platforms:\n");
-    const allPlatforms = [
-      { name: "OpenCode", adapter: new OpenCodeAdapter() },
-      { name: "Claude Code", adapter: new ClaudeAdapter() },
-      { name: "VSCode", adapter: new VSCodeAdapter() }
-    ];
-    for (const { name, adapter } of allPlatforms) {
+    for (const adapter of allAdapters) {
       const isAvailable = available.find((a) => a.id === adapter.id);
       const installed = await adapter.listInstalled();
       if (isAvailable) {
-        console.log(`${name.padEnd(12)} \u2705  Available (${installed.length} skills installed)`);
+        console.log(`${adapter.name.padEnd(15)} \u2705  Available (${installed.length} skills installed)`);
       } else {
-        console.log(`${name.padEnd(12)} \u274C  Not detected`);
+        console.log(`${adapter.name.padEnd(15)} \u274C  Not detected`);
       }
     }
     console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itismyskillmarket",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Cross-platform skill manager for AI coding tools",
   "type": "module",
   "bin": {

package/src/adapters/hermes.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HermesAdapter } from './hermes.js';
+import { join } from 'path';
+import { homedir } from 'os';
+
+describe('HermesAdapter', () => {
+  let adapter: HermesAdapter;
+
+  beforeEach(() => {
+    adapter = new HermesAdapter();
+  });
+
+  it('should have id "hermes"', () => {
+    expect(adapter.id).toBe('hermes');
+  });
+
+  it('should have name "Hermes Agent"', () => {
+    expect(adapter.name).toBe('Hermes Agent');
+  });
+
+  it('should have correct skillDir', () => {
+    expect(adapter.skillDir).toBe(join(homedir(), '.hermes', 'skills'));
+  });
+
+  it('should check availability based on ~/.hermes/ existence', async () => {
+    const result = await adapter.isAvailable();
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('should check if skill is installed', async () => {
+    const result = await adapter.isInstalled('test-skill');
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('should list installed skills', async () => {
+    const result = await adapter.listInstalled();
+    expect(Array.isArray(result)).toBe(true);
+  });
+});

package/src/adapters/hermes.ts

@@ -0,0 +1,77 @@
+/**
+ * Hermes Agent Platform Adapter
+ * 
+ * Installs skills to ~/.hermes/skills/
+ * Hermes also supports project-level skills/ directory
+ * Hermes uses AgentSkills-compatible SKILL.md format with metadata.hermes
+ */
+import { PlatformAdapter } from './base.js';
+import { readdirSync, existsSync, cpSync, rmSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureDirSync } from 'fs-extra';
+
+export class HermesAdapter implements PlatformAdapter {
+  readonly id = 'hermes';
+  readonly name = 'Hermes Agent';
+  readonly skillDir = join(homedir(), '.hermes', 'skills');
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      // Check global hermes directory
+      if (existsSync(join(homedir(), '.hermes'))) {
+        return true;
+      }
+      
+      // Could also check for project-level skills/ directory
+      // but for SkillMarket, we focus on global installation
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  async isInstalled(skillId: string): Promise<boolean> {
+    try {
+      const skillPath = join(this.skillDir, skillId);
+      return existsSync(skillPath);
+    } catch {
+      return false;
+    }
+  }
+
+  async install(skillId: string, sourceDir: string): Promise<void> {
+    ensureDirSync(this.skillDir);
+    const targetDir = join(this.skillDir, skillId);
+    
+    // Remove existing skill directory if present
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+    
+    // Copy entire skill directory (SKILL.md + supporting files)
+    cpSync(sourceDir, targetDir, { recursive: true });
+  }
+
+  async uninstall(skillId: string): Promise<void> {
+    const targetDir = join(this.skillDir, skillId);
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+  }
+
+  async listInstalled(): Promise<string[]> {
+    try {
+      if (!existsSync(this.skillDir)) {
+        return [];
+      }
+      return readdirSync(this.skillDir)
+        .filter(name => {
+          const fullPath = join(this.skillDir, name);
+          return existsSync(fullPath) && name !== '.';
+        });
+    } catch {
+      return [];
+    }
+  }
+}

package/src/adapters/index.ts

@@ -6,4 +6,6 @@ export { BaseAdapter } from './base.js';
 export { OpenCodeAdapter } from './opencode.js';
 export { ClaudeAdapter } from './claude.js';
 export { VSCodeAdapter } from './vscode.js';
+export { OpenClawAdapter } from './openclaw.js';
+export { HermesAdapter } from './hermes.js';
 export { detectPlatforms, getPlatformAdapter, getAllAdapters, getAdapterByPlatform } from './registry.js';

package/src/adapters/openclaw.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { OpenClawAdapter } from './openclaw.js';
+import { readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+describe('OpenClawAdapter', () => {
+  let adapter: OpenClawAdapter;
+
+  beforeEach(() => {
+    adapter = new OpenClawAdapter();
+  });
+
+  it('should have id "openclaw"', () => {
+    expect(adapter.id).toBe('openclaw');
+  });
+
+  it('should have name "OpenClaw"', () => {
+    expect(adapter.name).toBe('OpenClaw');
+  });
+
+  it('should have correct skillDir', () => {
+    expect(adapter.skillDir).toBe(join(homedir(), '.openclaw', 'skills'));
+  });
+
+  it('should check availability based on ~/.openclaw/ existence', async () => {
+    const result = await adapter.isAvailable();
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('should check if skill is installed', async () => {
+    const result = await adapter.isInstalled('test-skill');
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('should list installed skills', async () => {
+    const result = await adapter.listInstalled();
+    expect(Array.isArray(result)).toBe(true);
+  });
+});

package/src/adapters/openclaw.ts

@@ -0,0 +1,69 @@
+/**
+ * OpenClaw Platform Adapter
+ * 
+ * Installs skills to ~/.openclaw/skills/
+ * OpenClaw uses AgentSkills-compatible SKILL.md format
+ */
+import { PlatformAdapter } from './base.js';
+import { readdirSync, existsSync, cpSync, rmSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureDirSync } from 'fs-extra';
+
+export class OpenClawAdapter implements PlatformAdapter {
+  readonly id = 'openclaw';
+  readonly name = 'OpenClaw';
+  readonly skillDir = join(homedir(), '.openclaw', 'skills');
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      return existsSync(join(homedir(), '.openclaw'));
+    } catch {
+      return false;
+    }
+  }
+
+  async isInstalled(skillId: string): Promise<boolean> {
+    try {
+      const skillPath = join(this.skillDir, skillId);
+      return existsSync(skillPath);
+    } catch {
+      return false;
+    }
+  }
+
+  async install(skillId: string, sourceDir: string): Promise<void> {
+    ensureDirSync(this.skillDir);
+    const targetDir = join(this.skillDir, skillId);
+    
+    // Remove existing skill directory if present
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+    
+    // Copy entire skill directory (SKILL.md + supporting files)
+    cpSync(sourceDir, targetDir, { recursive: true });
+  }
+
+  async uninstall(skillId: string): Promise<void> {
+    const targetDir = join(this.skillDir, skillId);
+    if (existsSync(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+  }
+
+  async listInstalled(): Promise<string[]> {
+    try {
+      if (!existsSync(this.skillDir)) {
+        return [];
+      }
+      return readdirSync(this.skillDir)
+        .filter(name => {
+          const fullPath = join(this.skillDir, name);
+          return existsSync(fullPath) && name !== '.';
+        });
+    } catch {
+      return [];
+    }
+  }
+}

package/src/adapters/registry.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { getAdapterByPlatform } from './registry.js';
+import { OpenClawAdapter } from './openclaw.js';
+import { HermesAdapter } from './hermes.js';
+
+describe('getAdapterByPlatform', () => {
+  it('should return OpenClawAdapter for "openclaw"', () => {
+    const adapter = getAdapterByPlatform('openclaw');
+    expect(adapter.id).toBe('openclaw');
+    expect(adapter.name).toBe('OpenClaw');
+  });
+
+  it('should return HermesAdapter for "hermes"', () => {
+    const adapter = getAdapterByPlatform('hermes');
+    expect(adapter.id).toBe('hermes');
+    expect(adapter.name).toBe('Hermes Agent');
+  });
+
+  it('should return adapter for "opencode"', () => {
+    const adapter = getAdapterByPlatform('opencode');
+    expect(adapter).toBeDefined();
+    expect(adapter.id).toBe('opencode');
+  });
+
+  it('should return undefined for unknown platform', () => {
+    const adapter = getAdapterByPlatform('unknown' as any);
+    expect(adapter).toBeUndefined();
+  });
+});

package/src/adapters/registry.ts

@@ -10,6 +10,8 @@
 import { OpenCodeAdapter } from './opencode.js';
 import { ClaudeAdapter } from './claude.js';
 import { VSCodeAdapter } from './vscode.js';
+import { OpenClawAdapter } from './openclaw.js';
+import { HermesAdapter } from './hermes.js';
 import type { PlatformAdapter } from '../types.js';
 import type { Platform } from '../constants.js';
 
@@ -22,10 +24,14 @@ function registerAdapters(): void {
   const opencode = new OpenCodeAdapter();
   const claude = new ClaudeAdapter();
   const vscode = new VSCodeAdapter();
+  const openclaw = new OpenClawAdapter();
+  const hermes = new HermesAdapter();
   
   adapters.set(opencode.id, opencode);
   adapters.set(claude.id, claude);
   adapters.set(vscode.id, vscode);
+  adapters.set(openclaw.id, openclaw);
+  adapters.set(hermes.id, hermes);
 }
 
 // Register adapters on module load
@@ -71,6 +77,8 @@ export function getAdapterByPlatform(platform: Platform): PlatformAdapter | unde
     cursor: 'opencode',  // Cursor uses OpenCode-compatible structure
     codex: 'opencode',  // Codex uses OpenCode-compatible structure
     antigravity: 'opencode',  // Antigravity uses OpenCode-compatible structure
+    openclaw: 'openclaw',
+    hermes: 'hermes',
   };
   
   return adapters.get(idMap[platform]);

package/src/cli.ts

@@ -49,7 +49,7 @@ import { syncPlatformLinks } from './commands/sync.js';  // 同步命令
 import { updateSkill } from './commands/update.js';     // 更新命令
 import { uninstallSkill, uninstallAll } from './commands/uninstall.js'; // 卸载命令
 import { installFromGitHub, parseGitHubUrl } from './commands/github-install.js'; // GitHub 安装
-import { detectPlatforms, getAllAdapters, OpenCodeAdapter, ClaudeAdapter, VSCodeAdapter } from './adapters/index.js'; // 平台适配器
+import { detectPlatforms, getAllAdapters } from './adapters/index.js'; // 平台适配器
 
 // -----------------------------------------------------------------------------
 // 创建命令程序实例
@@ -417,23 +417,18 @@ platformsCmd
   .action(async () => {
     try {
       const available = await detectPlatforms();
+      const allAdapters = getAllAdapters();
       
       console.log('\n📍 Available Platforms:\n');
       
-      const allPlatforms = [
-        { name: 'OpenCode', adapter: new OpenCodeAdapter() },
-        { name: 'Claude Code', adapter: new ClaudeAdapter() },
-        { name: 'VSCode', adapter: new VSCodeAdapter() },
-      ];
-      
-      for (const { name, adapter } of allPlatforms) {
+      for (const adapter of allAdapters) {
         const isAvailable = available.find(a => a.id === adapter.id);
         const installed = await adapter.listInstalled();
         
         if (isAvailable) {
-          console.log(`${name.padEnd(12)} ✅  Available (${installed.length} skills installed)`);
+          console.log(`${adapter.name.padEnd(15)} ✅  Available (${installed.length} skills installed)`);
         } else {
-          console.log(`${name.padEnd(12)} ❌  Not detected`);
+          console.log(`${adapter.name.padEnd(15)} ❌  Not detected`);
         }
       }
       

package/src/constants.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { PLATFORMS } from './constants.js';
+
+describe('PLATFORMS', () => {
+  it('should include openclaw', () => {
+    expect(PLATFORMS).toContain('openclaw');
+  });
+
+  it('should include hermes', () => {
+    expect(PLATFORMS).toContain('hermes');
+  });
+
+  it('should maintain existing platforms', () => {
+    expect(PLATFORMS).toContain('opencode');
+    expect(PLATFORMS).toContain('claude');
+    expect(PLATFORMS).toContain('vscode');
+  });
+});

package/src/constants.ts

@@ -81,7 +81,9 @@ export const PLATFORMS = [
   'codex',       // OpenAI Codex - OpenAI 代码生成模型
   'opencode',    // OpenCode - 开源 AI 编程工具
   'claude',      // Claude Code - Anthropic CLI 工具
-  'antigravity'  // Antigravity - AI 编程助手
+  'antigravity',  // Antigravity - AI 编程助手
+  'openclaw',    // OpenClaw - AgentSkills compatible agent
+  'hermes',      // Hermes Agent - NousResearch agent framework
 ] as const;
 
 /**