Library-first installer engine for Agent Skills across multiple providers
Agent-native second brain skill installer
KnowledgeSpace CLI + SKILL installer for OpenClaw
KnowledgeSpace CLI + SKILL installer for Hermes
KnowledgeSpace CLI + SKILL installer for Kepaw
KnowledgeSpace CLI + SKILL installer for Claude Code
Local 12ui Codex Design app and Codex skill installer
Secure multi-platform AI skill installer — scan before you install
Agent Skill installer for operating CoBridge through the CLI command contract.
Harmoney financial research skill installer
TapTap data team skill installer (wrapper around vercel-labs/skills with KB + MCP support)
Universal skill installer for OpenTIL
Local-first Agent Markdown runtime, validator, browser viewer, and agent skill installer.
Meta-extension bundling the MCP installer and skill installer for agent-facing Liche CLIs.
Nexgo internal skill installer CLI with skills.sh compatibility mode
Shared agent skill installer helpers for Hexbus CLIs.
OneClear industrial dust-collection filter-media presales skill installer.
HTTP-only Super API skill installer for Claude Code, Codex, and OpenClaw
Codex and Claude Code skill installer for Beehive XR workflows
SocialDataX / 社媒数据助手 skill installer and direct CLI helper for hosted platform social media MCP services.
Universal skill installer for AI coding agents - Claude, Cursor, Copilot, and more
Windows-only Codex skill installer for project-scoped best memory.
KnowledgeSpace CLI + SKILL installer
TikOmni skill installer CLI for structured social media crawling in Codex, Claude Code, and OpenClaw
Library and CLI for installing agent skills
LLM-native command-line interface for HubSpot CRM API
Seiro MCP is an MCP server focused on spatial computing development. Today it provides tools to safely run visionOS project builds from Codex CLI, supporting autonomous AI-assisted coding workflows.
LLM-friendly packet dissector CLI
CLI-first API testing tool
Language Server Protocol implementation for Tarn .tarn.yaml test files
MCP server for Tarn API testing tool
local prompt-injection scanner for claude skills, MCP server tool descriptions, and AGENTS.md. fast, offline, ci-friendly.
A CLI to install Claude Code skills written in pure Ruby (stdlib only). Skills are fetched from GitHub and installed to ~/.claude/skills/.
A CLI to install Claude Code skills written in pure Ruby (stdlib only). Skills are fetched from GitHub and installed to ~/.claude/skills/.
DEPRECATED: This gem is no longer maintained. Use pay-cli (cargo install pay-cli) or pay SDKs (pip install pay-sdk / npm install @pay-skill/sdk). See https://pay-skill.com/docs for migration.
cangming-ai-dev-kit provides cross-agent development skills (plan-first, safe-code-change, code-review, verify-before-done), domain-specific knowledge (Flutter/Dart, HarmonyOS/ArkTS/ArkUI), and shell scripts. Install with `gem install` and use the CLI to sync skills to Claude Code or Codex.
A Ruby library that provides a unified interface for discovering and accessing skill configuration paths for 49+ AI coding agents including Cursor, Claude Code, Codex, Windsurf, and more. Handles platform-specific path resolution, environment variable support, and automatic detection of installed agents.
+pikuri+ is the convenience bundle for the pikuri AI-assistant toolkit. It ships no Ruby code of its own beyond a tiny entry file that +require+'s each sibling gem; +gem install pikuri+ pulls in pikuri-core, pikuri-skills, pikuri-tasks, pikuri-memory, pikuri-workspace, pikuri-code, pikuri-mcp, pikuri-subagents, pikuri-vectordb, and pikuri-assistant in one shot, and +require 'pikuri'+ boots all of them. Privacy-conscious users who want a minimal dependency tree to audit should install +pikuri-core+ directly and opt into the extension gems they actually need — same +bundle add+ pattern Rails users have always had. See each pikuri-* gem's README for its individual surface.
pikuri-core is the lean, audit-friendly foundation of the pikuri family: Pikuri::Agent (a thin wrapper around ruby_llm's chat loop) with its Configurator + Extension protocol, the strict Pikuri::Tool framework, a listener surface for rendering / budgets / sub-agents, and four bundled stateless tools (calculator, web search, web scrape, fetch). Extensions (skills, MCP, workspace, coding stack, named-agent personas) live in sibling gems so a privacy-conscious user can install just this core and audit a minimal dependency tree. For the convenience bundle that pulls in everything, see the +pikuri+ metagem.
<!-- TABLE OF CONTENTS --> <details open="open"> <summary>Table of Contents</summary> <ol> <li> <a href="#about-the-project">About The Project</a> <ul> <li><a href="#built-with">Built With</a></li> </ul> </li> <li> <a href="#getting-started">Getting Started</a> <ul> <li><a href="#prerequisites">Prerequisites</a></li> <li><a href="#installation">Installation</a></li> </ul> </li> <li><a href="#usage">Usage</a></li> <li><a href="#roadmap">Roadmap</a></li> <li><a href="#contributing">Contributing</a></li> <li><a href="#license">License</a></li> <li><a href="#contact">Contact</a></li> <li><a href="#acknowledgements">Acknowledgements</a></li> </ol> </details> <!-- ABOUT THE PROJECT --> ## About The Project [![Product Name Screen Shot][Screenshot of gameplay and test list]](https://www.dropbox.com/s/mu1rrbx2mqowjkn/studio-game.png?dl=0) This game is a project built following the [Pragmatic Studio Ruby Course](https://online.pragmaticstudio.com/courses/ruby/). I absolutely adored going through this course, because it was unlike other courses in that the main focus wasn't syntax, but how to build a principle-driven, object-oriented program that contains many of the skills we'd need to build real-world projects. The instructors purposefully created exercises to let us build a program using the skills they demonstrated by building a different program. This wasn't a copy and paste kind of course. This game was actually my second run-through, where I test-drove everything from the start based on the objectives only. Skills I valued developing further with this project: - Test-driven development (50+ tests). - Using inheritance to model "is-a" relationships. For example, a clumsy player *is a* kind of player. - Using mixins (modules) to reuse behaviours that are common between classes, but should not be modeled with an inheritance relationship. A good tip was to look for 'able' behaviors in a class to extract, like 'playable', 'printable', 'taxable' etc. - Using a file block which lets you add in class usage examples that are only run when you run the class file specifically. - Overriding default methods (like sort, and renaming things so that they keep a specific format) Things I struggled with: - Testing behaviour that uses blocks. I had a lightbulb moment when I realised I should test the behaviour performed inside the block on a single item. Testing the output of an entire block is like testing Ruby syntax works. Alternatively, test the before and after state of something that changes as a result of using a block. Cooool. - Puts. It felt wrong to use puts to show the output in the console. I'd like to learn how to seperate the view logic for a command-line project later. Things I did to make it my own: - Wrote a lot more tests for my second run-through. - Noticed and extracted further 'able' behaviours into modules (like printing stats, formatting output and handling csv files). ### Built With * [Ruby (language)](https://www.ruby-lang.org/en/) * [RSpec (framework)](https://rspec.info/) * [Vim (text-editor)](https://www.vim.org/) <!-- GETTING STARTED --> ## Getting Started To get a local copy up and running follow these steps: ### Prerequisites This is an example of how to list things you need to use the software and how to install them. * gem ```sh npm install npm@latest -g ``` ### Installation 1. Install the gem ```sh gem install studio_game_2021 ``` <!-- USAGE EXAMPLES --> ## Usage To play a game from the command-line, open a new command project and run the command-line script like so: ```sh studio_game ``` Or, if you'd like to use the game as a library, here's an example of how to use it in `irb`. You can also check the bottom of each class or module file for further usage instructions ``` >> require 'studio_game/game' => true >> game = StudioGame::Game.new("Knuckleheads") => #<StudioGame::Game:0x007fdea10252d8 @title="Knuckleheads", @players=[]> >> player = StudioGame::Player.new("Moe", 90) => I'm Moe with health = 90, points = 0, and score = 90. >> game.add_player(player) => [I'm Moe with health = 90, points = 0, and score = 90.] >> game.play(1) ``` <!-- ROADMAP --> ## Roadmap I plan to customize this game further now that I have a solid foundation to explore from. It'll be fun to let the players interact with each other more, like swapping treasures, and maybe add some kind of board game with it's own features. That's my next focus. ## Contributing Feel free to fork this project and play around with it. Open to feedback-related pr requests. <!-- LICENSE --> ## License Distributed under the MIT License. See `LICENSE` for more information. <!-- CONTACT --> ## Contact Becca - [@becca9941](https://twitter.com/Becca9941) - becca@essentialistdev.com Project Link: [https://gitlab.com/EssentialistDev/studio-game](https://gitlab.com/EssentialistDev/studio-game) <!-- ACKNOWLEDGEMENTS --> ## Acknowledgements - [Pragmatic Studio](https://online.pragmaticstudio.com/courses/ruby/) for empowering me with awesome new development skills. - [Best-README-Template](https://github.com/Becca9941/Best-README-Template) for helping me write a README for this project.