Skip to content
Back to search

goskills

A tool supports OPENAI and other LLMs with Claude Skills, you can also use it as a subagent

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/smallnest--goskills/badge.svg)](/listings/smallnest--goskills)

HTML

<a href="/listings/smallnest--goskills"><img src="/api/listings/smallnest--goskills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

From Source

git clone https://github.com/smallnest/goskills.git
cd goskills
make

Using Homebrew

brew install smallnest/goskills/goskills

Or:

# add tap
brew tap smallnest/goskills

# install goskills
brew install goskills

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 258 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # GoSkills - Claude Skills Management Tool
  2. English | [简体中文](README_CN.md)
  3. A powerful command-line tool to parse, manage, and execute Claude Skill packages. GoSkills is designed according to the specifications found in the [official Claude documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/).
  4. [![License](https://img.shields.io/:license-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![github actions](https://github.com/smallnest/goskills/actions/workflows/go.yml/badge.svg)](https://github.com/smallnest/goskills/actions) [![Go Report Card](https://goreportcard.com/badge/github.com/smallnest/goskills)](https://goreportcard.com/report/github.com/smallnest/goskills)
  5. ## Features
  6. - **Skill Management**: List, search, parse, and inspect Claude skills from local directories
  7. - **Runtime Execution**: Execute skills with LLM integration (OpenAI, Claude, and compatible APIs)
  8. - **Web Interface**: Interactive chat UI with real-time updates, session replay, and rich artifact rendering (PPT, Podcasts)
  9. - **Rich Content Generation**: Generate PowerPoint presentations (via Slidev) and Podcast audio
  10. - **Deep Research**: Recursive analysis and self-correction capabilities for in-depth investigation
  11. - **Built-in Tools**: Shell commands, Python execution, file operations, web fetching, and search
  12. - **MCP Support**: Model Context Protocol (MCP) server integration
  13. - **Internationalization**: Full support for English and Chinese languages
  14. - **Comprehensive Testing**: Full test suite with coverage reports
  15. ## Installation
  16. ### From Source
  17. ```shell
  18. git clone https://github.com/smallnest/goskills.git
  19. cd goskills
  20. make
  21. ```
  22. ### Using Homebrew
  23. ```shell
  24. brew install smallnest/goskills/goskills
  25. ```
  26. Or:
  27. ```shell
  28. # add tap
  29. brew tap smallnest/goskills
  30. # install goskills
  31. brew install goskills
  32. ```
  33. ## Quick Start
  34. ```shell
  35. # Set your OpenAI API key
  36. export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
  37. # Optional: Use DeepSeek API (recommended for better performance)
  38. export OPENAI_API_KEY="sk-..."
  39. export OPENAI_MODEL="deepseek-chat"
  40. export OPENAI_API_BASE="https://api.deepseek.com/v1"
  41. # Start the Web Interface
  42. ./agent-web
  43. # List available skills
  44. ./goskills-cli list ./skills
  45. # Run a skill using the runner
  46. ./goskills run "create a react component for a todo app"
  47. # Run a skill using the the specified skill
  48. goskills run "calculate sin(radians(30))" --skill calculator-skill
  49. ```
  50. ## Built-in Tools
  51. GoSkills includes a comprehensive set of built-in tools for skill execution:
  52. - **Shell Tools**: Execute shell commands and scripts
  53. - **Python Tools**: Run Python code and scripts
  54. - **File Tools**: Read, write, and manage files
  55. - **Web Tools**: Fetch and process web content
  56. - **Search Tools**: Wikipedia and Tavily search integration
  57. - **MCP Tools**: Integration with Model Context Protocol servers
  58. ## CLI Tools
  59. GoSkills provides a suite of tools for different purposes:
  60. ### 1. Web Interface (`agent-web`)
  61. A modern web-based interface for interacting with GoSkills agents.
  62. - **Chat**: Real-time conversation with agents.
  63. - **Artifacts**: View generated Reports, PPTs, and Podcasts directly in the browser.
  64. - **History**: Replay and review past sessions.
  65. - **Localization**: Toggle between English and Chinese interfaces.
  66. ### 2. Skill Management CLI (`goskills-cli`)
  67. Located in `cmd/goskills-cli`, this tool helps you inspect and manage your local Claude skills.
  68. #### Building `goskills-cli`
  69. ```shell
  70. make cli
  71. # or
  72. go build -o goskills-cli ./cmd/goskills-cli
  73. ```
  74. #### Available Commands
  75. - **list**: Lists all valid skills in a given directory.
  76. - **parse**: Parses a single skill and displays a summary of its structure.
  77. - **detail**: Displays the full, detailed information for a single skill.
  78. - **files**: Lists all the files that make up a skill package.
  79. - **search**: Searches for skills by name or description.
  80. ### 3. Skill Runner CLI (`goskills`)
  81. Located in `cmd/goskills`, this tool simulates the Claude skill-use workflow by integrating with Large Language Models (LLMs) like OpenAI's models.
  82. #### Building `goskills` runner
  83. ```shell
  84. make runner
  85. # or
  86. go build -o goskills ./cmd/goskills
  87. ```
  88. #### Available Commands
  89. #### download
  90. Downloads a skill package from a GitHub directory URL to `~/.goskills/skills`.
  91. ```shell
  92. # Download a skill from GitHub
  93. ./goskills download https://github.com/ComposioHQ/awesome-claude-skills/tree/master/meeting-insights-analyzer
  94. # Download a skill with subdirectories
  95. ./goskills download https://github.com/ComposioHQ/awesome-claude-skills/tree/master/artifacts-builder
  96. ```
  97. The download command will:
  98. - Automatically create the `~/.goskills/skills` directory if it doesn't exist
  99. - Recursively download all files and subdirectories
  100. - Extract the skill name from the URL and use it as the target directory name
  101. - Prevent duplicate downloads with error messages
  102. #### run
  103. Processes a user request by first discovering available skills, then asking an LLM to select the most appropriate one, and finally executing the selected skill.
  104. **Requires the `OPENAI_API_KEY` environment variable to be set.**
  105. ```shell
  106. # Example with default OpenAI model (gpt-4o)
  107. export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
  108. ./goskills run "create an algorithm that generates abstract art"
  109. # Example with a custom OpenAI-compatible model and API base URL using environment variables
  110. export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
  111. export OPENAI_API_BASE="https://qianfan.baidubce.com/v2"
  112. export OPENAI_MODEL="deepseek-v3"
  113. ./goskills run "create an algorithm that generates abstract art"
  114. # Example with a custom OpenAI-compatible model and API base URL using command-line flags
  115. export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
  116. ./goskills run --model deepseek-v3 --api-base https://qianfan.baidubce.com/v2 "create an algorithm that generates abstract art"
  117. # Example with a custom OpenAI-compatible model and API base URL using command-line flags, auto-approve without human-in-the-loop
  118. ./goskills run --auto-approve --model deepseek-v3 --api-base https://qianfan.baidubce.com/v2 "使用markitdown 工具解析网页 https://baike.baidu.com/item/%E5%AD%94%E5%AD%90/1584"
  119. # Example with a custom OpenAI-compatible model and API base URL using command-line flags, in a loop mode and not exit automatically
  120. ./goskills run --auto-approve --model deepseek-v3 --api-base https://qianfan.baidubce.com/v2 --skills-dir=~/.goskills/skills "使用markitdown 工具解析网 页 https://baike.baidu.com/item/%E5%AD%94%E5%AD%90/1584" -l
  121. ```
  122. ## Development
  123. ### Make Commands
  124. The project includes a comprehensive Makefile for development tasks:
  125. ```shell
  126. # Help - shows all available commands
  127. make help
  128. # Build
  129. make build # Build both CLI and runner
  130. make cli # Build CLI only
  131. make runner # Build runner only
  132. # Testing
  133. make test # Run all tests
  134. make test-race # Run tests with race detector
  135. make test-coverage # Run tests with coverage report
  136. make benchmark # Run benchmarks
  137. # Code Quality
  138. make check # Run fmt-check, vet, and lint
  139. make fmt # Format all Go files
  140. make vet # Run go vet
  141. make lint # Run golangci-lint
  142. # Dependencies
  143. make deps # Download dependencies
  144. make tidy # Tidy and verify dependencies
  145. # Other
  146. make clean # Clean build artifacts
  147. make install-tools # Install development tools
  148. make info # Display project information
  149. ```
  150. ### Running All Tests
  151. ```shell
  152. # Run comprehensive test suite
  153. make test-coverage
  154. # Run specific tool tests
  155. cd tool && ./test_all.sh
  156. ```
  157. ## Configuration
  158. ### Environment Variables
  159. - `OPENAI_API_KEY`: OpenAI API key for LLM integration
  160. - `OPENAI_API_BASE`: Custom API base URL (optional)
  161. - `OPENAI_MODEL`: Custom model name (optional)
  162. - `TAVILY_API_KEY`: Tavily search API key
  163. - `MCP_CONFIG`: Path to MCP configuration file
  164. ### MCP Integration
  165. Configure Model Context Protocol (MCP) servers by creating a `mcp.json` file:
  166. ```json
  167. {
  168. "mcpServers": {
  169. "server-name": {
  170. "command": "path/to/server",
  171. "args": ["arg1", "arg2"]
  172. }
  173. }
  174. }
  175. ```
  176. ## Contributing
  177. 1. Fork the repository
  178. 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
  179. 3. Make your changes
  180. 4. Run tests (`make test`)
  181. 5. Run linting (`make check`)
  182. 6. Commit your changes (`git commit -m 'Add amazing feature'`)
  183. 7. Push to the branch (`git push origin feature/amazing-feature`)
  184. 8. Open a Pull Request
  185. ## License
  186. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.