itismyskillmarket 1.3.3 → 1.3.4

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() {
@@ -584,8 +701,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]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itismyskillmarket",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "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/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;
 
 /**