How to Run Tests for the Marketingskills Project: Validation and Linting Guide

The marketingskills repository does not include a traditional automated test suite; instead, it relies on built-in validation scripts that lint skill files and verify compliance with the Agent Skills specification.

The marketingskills project by coreyhaines31 is a collection of content-only Agent Skills and zero-dependency CLI tools. While it lacks conventional unit tests found in typical Node.js or Python projects, the repository provides robust validation mechanisms to ensure every skill meets the Agent Skills specification. This guide covers exactly how to run tests and validation checks for the marketingskills project using the built-in Bash helpers and Node.js syntax verification.

Run the Built-in Validation Scripts

The repository ships with two primary Bash scripts located in the root directory that serve as the main testing mechanism. These scripts validate Markdown skill definitions and ensure proper formatting rather than running unit tests.

Use validate-skills.sh for Standard Validation

The validate-skills.sh script executes the public validation workflow by running npm run lint && npm run check-skills. This checks that all skill files are properly formatted and syntactically correct.

Execute the script from the repository root:

chmod +x validate-skills.sh
./validate-skills.sh

The script exits with a non-zero status if any skill fails validation, making it suitable for CI pipelines and pre-commit hooks.

Use validate-skills-official.sh for Specification Compliance

The validate-skills-official.sh script runs the official validation pipeline defined by the Agent Skills specification. This performs stricter checks including YAML front-matter validation, line-length limits enforcement, and verification of required fields.

Run the official validator:

./validate-skills-official.sh

This script is the authoritative check for whether your skills comply with the official Agent Skills standard and will catch formatting issues that the standard validator might miss.

Syntax Check CLI Tools with Node.js

All CLI tools under tools/clis/ are plain JavaScript files designed to run with zero dependencies. Since there are no unit test files (*.spec.js or *.test.js), you verify correctness using Node.js built-in syntax checking.

Verify syntax for individual CLI tools using node --check:

node --check tools/clis/zoominfo.js

To validate the entire CLI suite at once, loop through the directory:

for file in tools/clis/*.js; do
  node --check "$file" || echo "Syntax error in $file"
done

You can also display usage information to verify the tool loads without errors (this runs the help text without making network calls):

node tools/clis/zoominfo.js --help

Execute the CI Workflow Locally

The repository includes a GitHub Actions configuration that automates the validation process on every push.

Locate the Workflow File

The CI pipeline is defined in .github/workflows/validate-skill.yml. This workflow runs the validation scripts automatically in a clean environment.

Reproduce GitHub Actions Locally

You can replicate the CI steps locally by running the validation scripts mentioned above. Alternatively, use the act tool to execute the workflow offline (requires separate installation of act). This runs the same checks that GitHub would run on your pull requests, ensuring your local environment matches the CI environment exactly.

Why No Traditional Unit Tests?

Because the repository consists of Markdown skill definitions and thin JavaScript wrappers rather than complex application logic, there are no unit or functional test suites. The Agent Skills are content-first artifacts where YAML front-matter compliance and file structure matter more than algorithmic correctness.

If you need automated testing for a custom skill you are developing, you would typically:

1. Write a separate test harness using Jest or pytest.
2. Load the skill's SKILL.md file and assert that required front-matter fields exist.
3. Run the CLI tool with the --dry-run flag to ensure it builds a request without contacting external APIs, as documented in the skill guidelines.

Summary

• No traditional test suite: The marketingskills project uses validation scripts instead of Jest, Mocha, or PyTest.
• Two validation scripts: Use validate-skills.sh for basic checks and validate-skills-official.sh for strict Agent Skills specification compliance.
• CLI verification: Syntax-check JavaScript files in tools/clis/ using node --check.
• CI integration: The .github/workflows/validate-skill.yml runs validation automatically on every push.
• Exit codes: Both validation scripts exit non-zero on failure, making them suitable for automated pipelines.

Frequently Asked Questions

Does marketingskills use Jest or Mocha for testing?

No. According to the coreyhaines31/marketingskills source code, the repository contains no Jest, Mocha, or PyTest configurations. Instead, testing is accomplished through Bash validation scripts that lint skills and verify YAML front-matter compliance against the Agent Skills specification.

What is the difference between validate-skills.sh and validate-skills-official.sh?

The validate-skills.sh script runs the public validation workflow (npm run lint && npm run check-skills), checking basic formatting and syntax. The validate-skills-official.sh script executes the official Agent Skills specification pipeline, which includes stricter checks for YAML front-matter structure, line-length limits, and required field presence. Use the official script when preparing skills for distribution.

How do I validate a single CLI tool instead of all skills?

Run node --check followed by the specific file path. For example: node --check tools/clis/zoominfo.js. This parses the JavaScript and reports any syntax errors without executing the full program, providing immediate feedback on code validity.

Can I run the GitHub Actions workflow locally?

Yes. Install the act tool separately, then use it to run the .github/workflows/validate-skill.yml workflow locally. This executes the same validation steps that GitHub runs on every push, allowing you to test your changes before committing them to the repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}