@opendirectory.dev/skills 0.1.0

package/dist/fs-adapters.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = resolvePath;
+exports.safeWriteFile = safeWriteFile;
+exports.safeAppendFile = safeAppendFile;
+exports.updateHermesConfig = updateHermesConfig;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+function resolvePath(p) {
+    if (p.startsWith('~/') || p === '~') {
+        return path.resolve(p.replace(/^~/, os.homedir()));
+    }
+    return path.resolve(p);
+}
+async function safeWriteFile(filePath, content) {
+    const resolvedPath = resolvePath(filePath);
+    const dir = path.dirname(resolvedPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(resolvedPath, content, 'utf-8');
+}
+async function safeAppendFile(filePath, content) {
+    const resolvedPath = resolvePath(filePath);
+    const dir = path.dirname(resolvedPath);
+    await fs.mkdir(dir, { recursive: true });
+    try {
+        const existingContent = await fs.readFile(resolvedPath, 'utf-8');
+        if (existingContent.includes(content)) {
+            return;
+        }
+        const prefix = existingContent.length > 0 && !existingContent.endsWith('\n') ? '\n' : '';
+        await fs.appendFile(resolvedPath, prefix + content, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            await fs.writeFile(resolvedPath, content, 'utf-8');
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function updateHermesConfig() {
+    const configPath = resolvePath('~/.hermes/config.yaml');
+    try {
+        let content = await fs.readFile(configPath, 'utf-8');
+        if (!content.includes('skills:')) {
+            const prefix = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+            content += prefix + 'skills:\n  external_dirs:\n    - "./.hermes/skills"\n';
+        }
+        else if (!content.includes('external_dirs:')) {
+            content = content.replace(/(skills:\s*\n)/, '$1  external_dirs:\n    - "./.hermes/skills"\n');
+        }
+        else if (!content.includes('./.hermes/skills')) {
+            content = content.replace(/(external_dirs:\s*\n)/, '$1    - "./.hermes/skills"\n');
+        }
+        await fs.writeFile(configPath, content, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            const initialContent = `skills:\n  external_dirs:\n    - "./.hermes/skills"\n`;
+            await safeWriteFile('~/.hermes/config.yaml', initialContent);
+        }
+        else {
+            throw error;
+        }
+    }
+}

package/dist/fs-adapters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fs-adapters.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const fs_adapters_1 = require("./fs-adapters");
+(0, vitest_1.describe)('fs-adapters', () => {
+    let tempDir;
+    (0, vitest_1.beforeEach)(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fs-adapters-test-'));
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.describe)('resolvePath', () => {
+        (0, vitest_1.it)('should resolve ~ to home directory', () => {
+            const home = os.homedir();
+            (0, vitest_1.expect)((0, fs_adapters_1.resolvePath)('~/foo/bar')).toBe(path.join(home, 'foo/bar'));
+            (0, vitest_1.expect)((0, fs_adapters_1.resolvePath)('~')).toBe(home);
+        });
+        (0, vitest_1.it)('should resolve absolute paths', () => {
+            const absPath = path.resolve('/foo/bar');
+            (0, vitest_1.expect)((0, fs_adapters_1.resolvePath)('/foo/bar')).toBe(absPath);
+        });
+        (0, vitest_1.it)('should resolve relative paths', () => {
+            const relPath = path.resolve('foo/bar');
+            (0, vitest_1.expect)((0, fs_adapters_1.resolvePath)('foo/bar')).toBe(relPath);
+        });
+    });
+    (0, vitest_1.describe)('safeWriteFile', () => {
+        (0, vitest_1.it)('should create directory and write file', async () => {
+            const filePath = path.join(tempDir, 'nested', 'dir', 'test.txt');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'hello world');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('hello world');
+        });
+        (0, vitest_1.it)('should overwrite existing file', async () => {
+            const filePath = path.join(tempDir, 'test.txt');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'hello world');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'new content');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('new content');
+        });
+    });
+    (0, vitest_1.describe)('safeAppendFile', () => {
+        (0, vitest_1.it)('should create file if it does not exist', async () => {
+            const filePath = path.join(tempDir, 'nested', 'test.txt');
+            await (0, fs_adapters_1.safeAppendFile)(filePath, 'hello world');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('hello world');
+        });
+        (0, vitest_1.it)('should append to existing file', async () => {
+            const filePath = path.join(tempDir, 'test.txt');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'line 1\n');
+            await (0, fs_adapters_1.safeAppendFile)(filePath, 'line 2');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('line 1\nline 2');
+        });
+        (0, vitest_1.it)('should add newline if existing file does not end with one', async () => {
+            const filePath = path.join(tempDir, 'test.txt');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'line 1');
+            await (0, fs_adapters_1.safeAppendFile)(filePath, 'line 2');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('line 1\nline 2');
+        });
+        (0, vitest_1.it)('should not append if content already exists', async () => {
+            const filePath = path.join(tempDir, 'test.txt');
+            await (0, fs_adapters_1.safeWriteFile)(filePath, 'existing content\nmore stuff');
+            await (0, fs_adapters_1.safeAppendFile)(filePath, 'existing content');
+            const content = await fs.readFile(filePath, 'utf-8');
+            (0, vitest_1.expect)(content).toBe('existing content\nmore stuff');
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const program = new commander_1.Command();
+program
+    .name('@opendirectory.dev/cli')
+    .description(chalk_1.default.blue.bold('CLI to install OpenDirectory skills'))
+    .version('0.1.0');
+const getProjectRoot = () => {
+    return path.resolve(__dirname, '..');
+};
+program
+    .command('list')
+    .description('List available skills in the Open Directory registry')
+    .action(async () => {
+    const spinner = (0, ora_1.default)('Fetching available skills...').start();
+    try {
+        const root = getProjectRoot();
+        const registryPath = path.join(root, 'registry.json');
+        let skills = [];
+        try {
+            const registryContent = await fs.readFile(registryPath, 'utf-8');
+            skills = JSON.parse(registryContent);
+        }
+        catch (e) {
+            const skillsDir = path.join(root, 'skills');
+            const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+            skills = entries
+                .filter(entry => entry.isDirectory())
+                .map(entry => ({ name: entry.name, description: `Skill: ${entry.name}` }));
+        }
+        spinner.stop();
+        console.log(chalk_1.default.green('Successfully loaded Open Directory registry!\n'));
+        const table = new cli_table3_1.default({
+            head: [chalk_1.default.cyan.bold('Skill Name'), chalk_1.default.cyan.bold('Description')],
+            colWidths: [35, 75],
+            wordWrap: true
+        });
+        for (const skill of skills) {
+            let desc = skill.description || '';
+            desc = desc.replace(/<img[^>]*>/g, '').trim();
+            if (desc.length > 100)
+                desc = desc.substring(0, 97) + '...';
+            table.push([chalk_1.default.yellow(skill.name), desc]);
+        }
+        console.log(table.toString());
+        console.log(chalk_1.default.gray(`\nRun \`${chalk_1.default.white('npx @opendirectory.dev/cli install <skill-name> --target <agent>')}\` to install a skill.`));
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk_1.default.red('Failed to list skills.'));
+        console.error(error);
+    }
+});
+program
+    .command('install <skill>')
+    .description('Install a skill for your AI agent')
+    .requiredOption('-t, --target <tool>', 'Target agent (opencode, claude, codex, gemini, anti-gravity, openclaw, hermes)')
+    .option('-g, --global', 'Install globally for all projects')
+    .action(async (skillName, options) => {
+    const spinner = (0, ora_1.default)(`Installing ${chalk_1.default.yellow(skillName)}...`).start();
+    try {
+        const root = getProjectRoot();
+        const repoDir = path.join(root, 'skills', skillName);
+        let skillDir = repoDir;
+        let skillMdPath = path.join(skillDir, 'SKILL.md');
+        try {
+            await fs.access(skillMdPath);
+        }
+        catch (e) {
+            try {
+                const entries = await fs.readdir(repoDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const possiblePath = path.join(repoDir, entry.name, 'SKILL.md');
+                        try {
+                            await fs.access(possiblePath);
+                            skillDir = path.join(repoDir, entry.name);
+                            skillMdPath = possiblePath;
+                            break;
+                        }
+                        catch (err) { }
+                    }
+                }
+                if (skillDir === repoDir) {
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git') {
+                            const subDir = path.join(repoDir, entry.name);
+                            const subEntries = await fs.readdir(subDir, { withFileTypes: true });
+                            for (const subEntry of subEntries) {
+                                if (subEntry.isDirectory()) {
+                                    const possiblePath = path.join(subDir, subEntry.name, 'SKILL.md');
+                                    try {
+                                        await fs.access(possiblePath);
+                                        skillDir = path.join(subDir, subEntry.name);
+                                        skillMdPath = possiblePath;
+                                        break;
+                                    }
+                                    catch (err) { }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (dirErr) {
+                spinner.stop();
+                console.error(chalk_1.default.red(`Error: Repository '${skillName}' not found.`));
+                console.log(chalk_1.default.gray(`Try running \`${chalk_1.default.white('npx @opendirectory.dev/cli list')}\` to see available skills.`));
+                process.exit(1);
+            }
+        }
+        try {
+            await fs.access(skillMdPath);
+        }
+        catch (e) {
+            spinner.stop();
+            console.error(chalk_1.default.red(`Error: Skill '${skillName}' missing SKILL.md in registry.`));
+            process.exit(1);
+        }
+        const actualSkillFolderName = path.basename(skillDir);
+        const finalSkillName = actualSkillFolderName === skillName ? skillName : actualSkillFolderName;
+        const target = options.target.toLowerCase();
+        const isGlobal = options.global;
+        const validTargets = ['opencode', 'claude', 'codex', 'gemini', 'anti-gravity', 'openclaw', 'hermes'];
+        if (validTargets.includes(target)) {
+            let targetFolder = '';
+            if (target === 'opencode')
+                targetFolder = isGlobal ? `~/.config/opencode/skills/${finalSkillName}` : `./.opencode/skills/${finalSkillName}`;
+            if (target === 'claude')
+                targetFolder = isGlobal ? `~/.claude/skills/${finalSkillName}` : `./.claude/skills/${finalSkillName}`;
+            if (target === 'codex')
+                targetFolder = isGlobal ? `~/.codex/skills/${finalSkillName}` : `./.codex/skills/${finalSkillName}`;
+            if (target === 'gemini')
+                targetFolder = isGlobal ? `~/.gemini/skills/${finalSkillName}` : `./.gemini/skills/${finalSkillName}`;
+            if (target === 'anti-gravity')
+                targetFolder = isGlobal ? `~/.gemini/antigravity/skills/${finalSkillName}` : `./.agent/skills/${finalSkillName}`;
+            if (target === 'openclaw')
+                targetFolder = isGlobal ? `~/.openclaw/skills/${finalSkillName}` : `./.openclaw/skills/${finalSkillName}`;
+            if (target === 'hermes')
+                targetFolder = isGlobal ? `~/.hermes/skills/${finalSkillName}` : `./.hermes/skills/${finalSkillName}`;
+            const { resolvePath, updateHermesConfig } = require('./fs-adapters');
+            const resolvedDest = resolvePath(targetFolder);
+            await fs.mkdir(resolvedDest, { recursive: true });
+            await fs.cp(skillDir, resolvedDest, { recursive: true });
+            if (target === 'hermes' && !isGlobal) {
+                await updateHermesConfig();
+            }
+            spinner.stop();
+            console.log(chalk_1.default.green(`Successfully installed ${chalk_1.default.bold(finalSkillName)}!`));
+            console.log(`\n  ${chalk_1.default.cyan('Agent:')}   ${target}`);
+            console.log(`  ${chalk_1.default.cyan('Scope:')}   ${isGlobal ? 'Global' : 'Local Project'}`);
+            console.log(`  ${chalk_1.default.cyan('Path:')}    ${targetFolder}\n`);
+        }
+        else {
+            spinner.stop();
+            console.error(chalk_1.default.red(`Error: Unsupported target '${target}'.`));
+            console.log(chalk_1.default.gray(`Supported targets: ${validTargets.join(', ')}`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk_1.default.red('Failed to install skill.'));
+        console.error(error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/transformers.d.ts

@@ -0,0 +1,6 @@
+export interface Skill {
+    name: string;
+    description: string;
+    content: string;
+    globs?: string;
+}

package/dist/transformers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@opendirectory.dev/skills",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "opendirectory": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').cpSync('../../skills', './skills', {recursive: true})\"",
+    "dev": "tsc -w",
+    "test:e2e": "vitest run src/e2e.test.ts"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/ora": "^3.2.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.6.1"
+  }
+}