Many changes, sorry for the size

[arran4]

I've attempted to bring this up to date so I could use it, I have made it a bit of my own sorry if that's an issue. Please provide feedback, etc. There was AI used in this let me know if that's also an issue.

Generated summary:

Summary

This PR modernises the project’s development and release workflow, expands the automated test coverage, improves command-line error handling, and fixes several Markdown conversion edge cases.

The main goals are to make the project easier to build, test, release, and maintain while preserving its existing lightweight implementation.

Changes

Add standard Go module support

• Add go.mod and go.sum.

• Allow the project to be built, tested, and installed using standard Go commands.

• Remove the Makefile, which only wrapped standard Go tooling.

• Update the README to document:

  • go run .
  • go test ./...
  • go install
  • installation from GitHub Releases

This reduces project-specific setup and makes the repository behave like a conventional Go project.

Add comprehensive CI and release automation

Add a GitHub Actions workflow covering automated validation and release-related tasks, including:

• builds and tests
• formatting and static analysis
• linting
• dependency and vulnerability checks
• secret scanning
• cross-platform build verification
• GoReleaser validation and release generation

Also add:

• .goreleaser.yml for reproducible binary releases
• .gitleaks.toml for secret-scanning configuration

This provides earlier feedback on regressions and makes releases repeatable rather than dependent on manual local steps.

Replace the ad hoc test program with Go tests

Remove the standalone test.go test runner and replace it with a normal testing package test suite.

Test cases are now stored as embedded txtar fixtures under testdata/txtar. Each fixture contains a Markdown input and its expected HTML output.

Coverage includes:

• paragraphs
• headings
• inline headings
• unordered and nested lists
• links
• emphasis
• strong text
• multiple inline constructs
• hard line breaks
• interactions between headings, paragraphs, and lists

The fixture-based structure makes failures easier to understand and allows new parser cases to be added without expanding a large table or creating another custom test mechanism.

Improve command-line handling

The command-line interface now:

• displays usage when no input file is supplied
• supports -h, --help, and -help
• accepts -nocss independently of argument order
• reports unknown flags
• rejects multiple input files
• reports errors through standard error
• avoids panics for normal user-input errors
• validates that the input has a .md extension
• correctly handles filenames containing multiple dots
• derives the output path using filepath.Ext and strings.TrimSuffix

For example, an input named release.notes.md now produces release.notes.html rather than relying on a fragile string split.

These changes make the program safer to invoke from scripts and provide clearer feedback when it is used incorrectly.

Improve file and write error handling

• Check errors returned while opening and creating files.
• Report failures with useful error messages.
• Flush the buffered writer explicitly.
• Handle input and output close errors more carefully.
• Avoid panicking for expected filesystem or argument errors.

This results in more predictable CLI behaviour and prevents failures from being silently ignored.

Fix Markdown hard line breaks

Support both CommonMark hard-break forms:

• two trailing spaces
• a trailing backslash

The parser now records whether a paragraph line ended in a hard break, rather than attempting to infer that later from generated HTML.

This keeps paragraph joining logic separate from inline conversion and avoids accidentally inserting spaces after <br>.

Improve parser reliability

The parser and generator have also received smaller correctness and maintainability fixes, including:

• clearer heading-level conversion
• corrected unreachable-code and return-path issues
• non-greedy matching for inline constructs
• repeated conversion of multiple inline elements on one line
• improved handling of whitespace
• tests for headings and paragraphs appearing around lists

Why this is better

The project now follows standard Go conventions and can be worked on without learning repository-specific build commands.

The expanded fixture-based test suite documents current behaviour and makes future parser changes safer. CI validates contributions consistently across formatting, tests, static analysis, security checks, and release configuration.

For users, the CLI is less likely to panic, produces clearer errors, supports more robust filename handling, and correctly recognises both standard hard-line-break forms.

For maintainers, releases become reproducible, regressions are easier to detect, and adding a parser test generally requires only a small input/output fixture.

Testing

Run the full test suite with:

go test ./...

The CI workflow also performs the broader linting, static-analysis, security, and release validation checks.