itismyskillmarket 1.3.2 → 1.3.4

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

@@ -48,6 +48,7 @@ import { installSkill } from './commands/install.js';   // 安装命令
 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'; // 平台适配器
 
 // -----------------------------------------------------------------------------
@@ -236,22 +237,38 @@ infoCmd
  * skm install brainstorming@1.0.0
  * skm install brainstorming --platform opencode
  */
-const installCmd = program.command('install').description('Install a skill to local and platform directories');
+const installCmd = program.command('install').description('Install a skill from npm or GitHub');
 installCmd
-  .argument('<skill>', 'Skill ID to install (e.g., brainstorming or @scope/name)')
+  .argument('<skill>', 'Skill ID, npm package, or GitHub URL (owner/repo, https://github.com/owner/repo)')
   .option('-p, --platform <platforms>', 'Target platforms (comma-separated: opencode,claude,vscode)')
   .option('-f, --force', 'Overwrite if already installed')
-  .option('-v, --version <version>', 'Specific version to install')
+  .option('-v, --version <version>', 'Specific version to install (npm only)')
+  .option('-b, --branch <branch>', 'GitHub branch to install from')
+  .option('-c, --commit <commit>', 'GitHub commit hash to install from')
   .action(async (skill, opts) => {
     try {
       const platforms = opts.platform 
         ? opts.platform.split(',').map((p: string) => p.trim())
         : undefined;
       
-      await installSkill(skill, opts.version, {
-        platforms,
-        force: opts.force
-      });
+      // 检测是否为 GitHub URL 或 owner/repo 格式
+      const githubSource = parseGitHubUrl(skill);
+      
+      if (githubSource) {
+        // GitHub 安装
+        await installFromGitHub(skill, {
+          platforms,
+          force: opts.force,
+          branch: opts.branch,
+          commit: opts.commit
+        });
+      } else {
+        // npm 安装
+        await installSkill(skill, opts.version, {
+          platforms,
+          force: opts.force
+        });
+      }
     } catch (err) {
       console.error('Installation failed:', err);
       process.exit(1);