Licensing

This project is MIT licensed. This skill covers dependency license compatibility and ethical code practices.

MIT: What It Means

Key point: MIT is maximally permissive. Users can do almost anything with the code as long as they include the copyright and license notice.

Compatible Dependency Licenses

Before adding a dependency, check its license. These are compatible with MIT:

Use With Caution

Incompatible (DO NOT USE)

Checking Dependency Licenses

Go Dependencies

# List all dependencies with licenses
go-licenses report ./... 2>/dev/null

# Or manually check go.mod imports
go list -m -json all | jq -r '.Path'
# Then check each on pkg.go.dev or GitHub

Before Adding a Dependency

1. •Check the LICENSE file in the repo
2. •Verify it's in the compatible list above
3. •If unclear, check SPDX identifier: https://spdx.org/licenses/

Planned Dependencies

Key dependencies and their licenses:

• •github.com/yuin/goldmark — MIT ✓
• •github.com/yuin/goldmark-highlighting — MIT ✓
• •go.abhg.dev/goldmark/mermaid — MIT ✓
• •github.com/alecthomas/chroma/v2 — MIT ✓

Writing Original Code

The Rule

Learn from other projects. Write your own code.

When studying how another project implements something:

1. •Understand the concept — What problem does it solve? What's the approach?
2. •Close the source — Don't have it open while writing
3. •Write from understanding — Implement based on your mental model
4. •Make it better — Your version should be at least as good, preferably superior

What's NOT Allowed

// WRONG: Copied from github.com/other/project
func ParseConfig(data []byte) (*Config, error) {
    // [copied code]
}

// WRONG: "Adapted" (minor variable renames)
func ParseConfiguration(input []byte) (*Configuration, error) {
    // [same logic, different names]
}

What IS Allowed

// RIGHT: Studied how X project handles URL rewriting,
// implemented our own version with better error messages
// and support for relative path resolution.
func RewriteRelativeURLs(doc []byte, baseURL string) []byte {
    // [original implementation]
}

Gray Areas

When In Doubt

1. •Can you explain it without looking at the source?
2. •Would your implementation differ if you'd never seen theirs?
3. •Are you copying structure or just learning a concept?

If yes to all three, you're probably fine.

Bundled Assets

Static assets embedded in the binary must have compatible licenses AND be documented:

Location: embed/LICENSES.md

Current bundled assets:

• •mermaid.js — MIT ✓
• •github-markdown-css — MIT ✓

When adding bundled assets:

1. •Verify license compatibility
2. •Add license text to embed/LICENSES.md
3. •Note version in Makefile (pinned versions)

License Headers

Go files don't require license headers (the root LICENSE file covers everything).

If you want to add headers for clarity in key files:

// Copyright 2026 air-gapped
// SPDX-License-Identifier: MIT

Quick Reference

Adding a dependency?
  → Check license is in compatible list
  → If not listed, investigate before using
  → Prefer MIT/Apache/BSD — avoid copyleft

Learning from another project?
  → Understand the concept
  → Write your own implementation
  → Make it better

Bundling static assets?
  → Check license compatibility
  → Document in embed/LICENSES.md