简体中文

docgen — Document Workshop skill pack

A set of document-generation skills in pure prompt (Agent Skills) form, providing four capabilities for plugin-based agent harnesses such as dsh: README generation, PR description generation, changelog generation, and code review. All skills follow the Agent Skills open standard (SKILL.md + YAML frontmatter), are self-contained, have no third-party dependencies, and work offline.

Included skills

Each skill is a self-contained single SKILL.md: the body contains input-collection guidance, a workflow, output templates with a template-variable table, language-style options, an output-quality checklist, a "don't" list, and edge-case handling.

Directory structure

docgen/
├── README.md                     # this document: installation, usage, interface
├── manifest.json                 # plugin manifest (self-describing metadata)
├── SKILLS.md                     # entry index file
├── LICENSE                       # MIT license
├── skills/                       # skills root (point here or copy entries when integrating)
│   ├── readme-forge/SKILL.md
│   ├── pr-dossier/SKILL.md
│   ├── changelog-curator/SKILL.md
│   └── diff-verdict/SKILL.md
├── examples/
│   ├── prompts.md                # example invocation prompts for each skill
│   └── dsh-patch-enable-skills.yml  # example dsh integration patch (enables skills in web profile + registers directory)
├── scripts/
│   └── validate_skills.py        # skill-pack validation script (Python standard library, no dependencies)
└── tests/
    └── test_validate_skills.py   # regression tests for the validation script

Installing in DSH

dsh plugin --profile demo add github:JohnXu22786/docgen

The exact wiring also depends on which profile the skill components are enabled in (see "Installation and dsh integration" below).

Installation and dsh integration

dsh discovers skills through the skill-filesystem provider by skills root directory (one level deep: directory bundles <root>/<name>/SKILL.md or flat files <root>/<name>.md). Pick any one of the following ways to integrate this pack:

Way one: project-level (recommended, zero config)

Put the four skill directories under skills/ (or the whole skills/) into the project's skills root:

# Any of these in the project root (the nearest ancestor containing .git):
#   <project>/.dsh/skills/    or   <project>/.agents/skills/
cp -r skills/* <project>/.dsh/skills/

Way two: user-level (available in all projects)

# $DSH_HOME defaults to ~/.dsh; $DSH_AGENTS_HOME defaults to ~/.agents
cp -r skills/* ~/.dsh/skills/

Way three: custom directory (in-place integration of the plugin, no copying)

Register customSkillDirs for the skill-filesystem provider via configuration, e.g. with a patch file (see examples/dsh-patch-enable-skills.yml):

npx @deepseek-ai/dsh web --patch ./examples/dsh-patch-enable-skills.yml

Note: dsh's web profile disables skill-related components by default (skill-filesystem / tool-skill); enable them with a patch or preset. The headless profile has them enabled by default. The exact config key paths depend on your installed version — check dsh --dump-config and the official docs.

Verifying the installation

python scripts/validate_skills.py            # validates this pack's skill format (exit code 0 when all pass)
python scripts/validate_skills.py --strict   # additionally checks the body line-count cap
python -m unittest discover -s tests -t .    # runs the validation script's own regression tests

After integration, just make natural-language requests in a session and the model loads the matching skill via the skill tool:

Write a README for this project
Generate a PR description for the change I just made
Update the changelog from git history and prepare 1.2.0
Help me review this PR

Usage

• Triggering: describe the need naturally in your prompt (see the "When to use" column of the skill table); you don't need to remember skill names. The harness routes automatically based on description / whenToUse.
• Style options: each skill supports three overridable dimensions — language (defaults to the language of the prompt), length (concise/standard/detailed or full), and tone/depth. Just append them in natural language: length=concise, focus=security, language=en.
• Output shape: skills produce markdown text directly; README/changelog-type skills give complete content you can save to a file as-is, while PR/review-type skills give structured descriptions or opinion lists.
• Example prompts: see examples/prompts.md.

Interface

Skill interface (dsh native contract)

Each skill is a directory bundle whose SKILL.md frontmatter is the only contract the harness reads:

dsh additionally recognizes (not written in this pack, defaults apply): disable-model-invocation and user-invocable (both open by default). Note: field names must be spelled exactly as in the table — allowed-tools contains a hyphen, and whenToUse is the established camelCase spelling; inconsistent spellings (e.g. writing allowed_tools or when-to-use) cause the field to be unrecognized; if an invocation-policy field is misspelled or mis-typed, dsh drops the entire skill (fail-closed).

Plugin manifest and entry

• manifest.json: the plugin's self-describing metadata (id / version / kind / entry / interface / skills / scripts). dsh's skill discovery does not read it; it serves human reference, publishing flows, and harnesses that support "entry file" style loaders; the interface field declares the skill-discovery contract.
• SKILLS.md: entry index listing the loading-contract summary and the skill list.

How dsh loads skills (summary)

dsh's skill capabilities are provided by three plugins working together — skill (registry), skill-filesystem (local discovery), and tool-skill (model catalog and skill tool): at startup it scans the root directories' frontmatter to build a catalog (the model only sees name + description); when the model decides to call a skill it reads the latest body by name; relative references in the body resolve against the skill directory. All four skills in this pack are single-file self-contained and do not depend on relative resources.

Development and extension

• Adding a skill: create a new directory + SKILL.md under skills/ (frontmatter per the table above), run python scripts/validate_skills.py until it passes, and update manifest.json and SKILLS.md accordingly.
• Modifying a skill: only edit the corresponding SKILL.md; the harness reads the new content on the next load (body changes need no catalog-cache restart).
• Validation script: scripts/validate_skills.py uses only the Python standard library and can be used standalone on any skill pack; it accepts arbitrary directories/files. Its parsing scope is a flat YAML subset (top-level key-values + metadata indented maps + quoted/list literals), without anchors, comments, or other full-YAML features.

Dependencies and privacy

• Zero third-party dependencies: pure prompts + a Python standard-library script;
• No network requests, no data collection; the only capabilities required are reading codebase files and git history (provided by the harness);
• License: MIT, see LICENSE.

FAQ

• Skills not visible in the web UI? The dsh web profile disables skill components by default; enable them with the Way-three patch (or use the CLI/headless profile).
• Changed SKILL.md but no effect? Skill bodies are read per invocation — just send a new request; if you changed the frontmatter name/description, the catalog refreshes via filesystem watching.
• Name collision with an existing skill? dsh resolves same-name skills by root-directory priority and layer proximity; all skill names in this pack are original — if there is a conflict, first check whether a same-name skill is already installed.

License

MIT — see LICENSE.