@oddessentials/repo-standards 1.0.1 → 1.1.0

package/dist/config/standards.json

@@ -6,7 +6,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -35,6 +37,20 @@
             ],
             "verification": ".gitignore must exist; .dockerignore is recommended when containerizing or using Docker workflows."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".gitignore",
+              ".dockerignore"
+            ],
+            "notes": "Use the official github/gitignore Go template. Exclude vendor/ (if not vendoring), *.exe, *.test, *.out, and IDE-specific files. .dockerignore must exclude .git and local build output.",
+            "optionalFiles": [
+              ".dockerignore"
+            ],
+            "requiredFiles": [
+              ".gitignore"
+            ],
+            "verification": ".gitignore must exist; .dockerignore is recommended when containerizing or using Docker workflows."
+          },
           "python": {
             "exampleConfigFiles": [
               ".gitignore",
@@ -49,6 +65,20 @@
             ],
             "verification": ".gitignore must exist; .dockerignore is recommended when containerizing or using Docker workflows."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              ".gitignore",
+              ".dockerignore"
+            ],
+            "notes": "Use the official github/gitignore Rust template. Exclude target/, Cargo.lock (for libraries), *.pdb, and similar build artifacts. .dockerignore must exclude target/, .git, and local development files.",
+            "optionalFiles": [
+              ".dockerignore"
+            ],
+            "requiredFiles": [
+              ".gitignore"
+            ],
+            "verification": ".gitignore must exist; .dockerignore is recommended when containerizing or using Docker workflows."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".gitignore",
@@ -70,7 +100,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -106,6 +138,25 @@
             ],
             "verification": ".editorconfig must exist to drive the .NET formatting and analysis tooling."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".golangci.yml",
+              ".golangci.yaml"
+            ],
+            "exampleTools": [
+              "golangci-lint",
+              "staticcheck"
+            ],
+            "notes": "Use golangci-lint as the primary linter aggregator. Configure enabled linters in .golangci.yml for consistent team-wide enforcement.",
+            "optionalFiles": [
+              ".golangci.yml",
+              ".golangci.yaml"
+            ],
+            "requiredFiles": [
+              "go.mod"
+            ],
+            "verification": ".golangci.yml or .golangci.yaml indicates linting is configured. Run 'golangci-lint run' to verify."
+          },
           "python": {
             "exampleConfigFiles": [
               "pyproject.toml",
@@ -128,6 +179,25 @@
             ],
             "verification": "pyproject.toml (or ruff.toml / .flake8) signals that linting tools are configured for the repository."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "clippy.toml",
+              ".clippy.toml"
+            ],
+            "exampleTools": [
+              "clippy",
+              "cargo-clippy"
+            ],
+            "notes": "Use Clippy for comprehensive Rust linting. Configure via clippy.toml for project-specific rules. Treat warnings as errors in CI with -D warnings.",
+            "optionalFiles": [
+              "clippy.toml",
+              ".clippy.toml"
+            ],
+            "requiredFiles": [
+              "Cargo.toml"
+            ],
+            "verification": "Clippy is available via rustup component. Run 'cargo clippy' to verify linting is configured."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".eslintrc.*"
@@ -162,7 +232,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -192,6 +264,20 @@
             ],
             "verification": "Test projects are present in the solution; test configuration is defined."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "go.mod"
+            ],
+            "exampleTools": [
+              "go test"
+            ],
+            "notes": "Use 'go test ./...' to run all tests. Place test files alongside source files with _test.go suffix. Keep unit tests fast and isolated.",
+            "optionalFiles": [],
+            "requiredFiles": [
+              "go.mod"
+            ],
+            "verification": "Run 'go test ./...' to verify the test suite is configured and passing."
+          },
           "python": {
             "exampleConfigFiles": [
               "pytest.ini",
@@ -211,6 +297,22 @@
             ],
             "verification": "Test framework configuration is present; tests/ directory or pytest configuration exists."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Cargo.toml"
+            ],
+            "exampleTools": [
+              "cargo test"
+            ],
+            "notes": "Use cargo test as the built-in test runner. Organize tests in tests/ directory for integration tests and inline #[test] functions for unit tests.",
+            "optionalFiles": [
+              "tests/"
+            ],
+            "requiredFiles": [
+              "Cargo.toml"
+            ],
+            "verification": "Run 'cargo test' to verify the test suite is configured and passing."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "jest.config.*"
@@ -237,7 +339,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -267,6 +371,21 @@
             ],
             "verification": "Dockerfile must be present; docker-compose.yml is optional and indicates orchestration usage."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "Dockerfile",
+              "docker-compose.yml"
+            ],
+            "exampleTools": [],
+            "notes": "Use multi-stage builds: builder stage with golang:alpine, then copy binary to scratch or distroless for minimal runtime. Set CGO_ENABLED=0 for static binaries.",
+            "optionalFiles": [
+              "docker-compose.yml"
+            ],
+            "requiredFiles": [
+              "Dockerfile"
+            ],
+            "verification": "Dockerfile must be present; docker-compose.yml is optional and indicates orchestration usage."
+          },
           "python": {
             "exampleConfigFiles": [
               "Dockerfile",
@@ -282,6 +401,21 @@
             ],
             "verification": "Dockerfile must be present; docker-compose.yml is optional and indicates orchestration usage."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Dockerfile",
+              "docker-compose.yml"
+            ],
+            "exampleTools": [],
+            "notes": "Use multi-stage builds: builder stage with rust:alpine for compiling, then copy binary to distroless or alpine for minimal runtime image. Pin Rust version via rust-toolchain.toml.",
+            "optionalFiles": [
+              "docker-compose.yml"
+            ],
+            "requiredFiles": [
+              "Dockerfile"
+            ],
+            "verification": "Dockerfile must be present; docker-compose.yml is optional and indicates orchestration usage."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "Dockerfile",
@@ -304,7 +438,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -331,6 +467,18 @@
             "notes": "Use GitVersion to automatically compute SemVer from git history and feed it into assembly/package versions. Configure CI to auto-generate or update CHANGELOG.md from commit messages and git tags. Integrate with release pipeline to automatically version assemblies, NuGet packages, and create release notes.",
             "verification": "Check that versioning is driven by a SemVer-aware tool (for example, GitVersion) and verify that running the release/versioning step locally or in CI automatically produces the expected version metadata, updates project files, and generates changelog entries from commit history."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".goreleaser.yml",
+              "CHANGELOG.md"
+            ],
+            "exampleTools": [
+              "goreleaser",
+              "semantic-release"
+            ],
+            "notes": "Go uses git tags for versioning (v1.2.3 format). Use goreleaser for automated releases with changelog generation. Tag versions consistently.",
+            "verification": "Check that git tags follow vMAJOR.MINOR.PATCH format and goreleaser or similar tool generates releases and changelogs."
+          },
           "python": {
             "exampleConfigFiles": [
               "pyproject.toml",
@@ -345,6 +493,18 @@
             "notes": "Automate version bumping and changelog generation using setuptools_scm (git-tag based) or bumpversion with towncrier for changelog fragments. Configure CI to automatically update version in pyproject.toml, generate/update CHANGELOG.md from commit messages or changelog fragments, and create git tags. Maintain a single source of truth for versioning.",
             "verification": "Check that the package version in pyproject or setup configuration follows SemVer and verify that the configured tool (for example, setuptools_scm or bumpversion) automatically computes or bumps the version and generates changelog entries from commit history or fragments."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Cargo.toml",
+              "CHANGELOG.md"
+            ],
+            "exampleTools": [
+              "cargo-release",
+              "semantic-release"
+            ],
+            "notes": "Version is defined in Cargo.toml. Use cargo-release or semantic-release-cargo for automated versioning. Follow Conventional Commits for changelog generation.",
+            "verification": "Check that Cargo.toml version follows SemVer and verify changelog generation from commit history."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".releaserc",
@@ -365,7 +525,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -392,6 +554,18 @@
             "notes": "Document your commit convention and wire up a helper tool so contributors can easily follow it.",
             "verification": "Create a test commit following the documented commit convention and confirm that any configured commit message checks (local hooks or CI) accept the message."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "commitlint.config.js",
+              ".cz.toml"
+            ],
+            "exampleTools": [
+              "commitlint",
+              "commitizen"
+            ],
+            "notes": "Use commitlint with pre-commit hooks for enforcing Conventional Commits. Consistent with goreleaser changelog generation.",
+            "verification": "Test that non-conforming commit messages are rejected by the configured hooks or CI check."
+          },
           "python": {
             "exampleConfigFiles": [
               ".cz.toml",
@@ -403,6 +577,18 @@
             "notes": "Standardize commit messages using commitizen or a similar helper and document the required types and scopes.",
             "verification": "Use the configured commit helper (for example, commitizen) or hooks to create a test commit and confirm that non-conforming messages are rejected while valid ones are accepted."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "commitlint.config.js",
+              ".cz.toml"
+            ],
+            "exampleTools": [
+              "commitlint",
+              "commitizen"
+            ],
+            "notes": "Use commitlint with husky or pre-commit for enforcing Conventional Commits. Works consistently with cargo workspaces.",
+            "verification": "Test that non-conforming commit messages are rejected by the configured hooks or CI check."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "commitlint.config.*"
@@ -421,7 +607,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -447,6 +635,17 @@
             "notes": "Enable coverage collection for test projects and publish reports in a human-friendly format from CI.",
             "verification": "Run the test suite with coverage enabled (for example, using coverlet or a similar tool) and verify that coverage reports are generated and used in CI to monitor thresholds."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "go.mod"
+            ],
+            "exampleTools": [
+              "go test -cover",
+              "go tool cover"
+            ],
+            "notes": "Use 'go test -coverprofile=coverage.out ./...' for coverage. Generate HTML or integrate with codecov/coveralls.",
+            "verification": "Run 'go test -cover ./...' and verify coverage reports are produced and thresholds monitored."
+          },
           "python": {
             "exampleConfigFiles": [
               "pytest.ini",
@@ -460,6 +659,18 @@
             "notes": "Configure coverage reporting for your test suite and surface summary metrics in CI.",
             "verification": "Run the unit tests with coverage (for example, pytest with pytest-cov) and confirm that coverage reports are generated and referenced in CI to enforce or track thresholds."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Cargo.toml"
+            ],
+            "exampleTools": [
+              "cargo-tarpaulin",
+              "llvm-cov",
+              "grcov"
+            ],
+            "notes": "Use cargo-tarpaulin or llvm-cov for code coverage. Generate lcov or cobertura reports for CI integration.",
+            "verification": "Run 'cargo tarpaulin' or equivalent and verify coverage reports are generated and thresholds enforced."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "jest.config.*"
@@ -478,7 +689,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -502,6 +715,15 @@
             "notes": "Ensure CI runs analyzers, tests, build, and packaging or container checks before changes can be merged.",
             "verification": "Open the CI configuration and verify there is a job or stage that runs analyzers, tests, build, and any required packaging or container checks before merging to main."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".github/workflows/*",
+              "azure-pipelines.yml"
+            ],
+            "exampleTools": [],
+            "notes": "Run 'golangci-lint run', 'go test ./...', 'go build' as quality gates. Use govulncheck for security scanning.",
+            "verification": "Verify CI runs golangci-lint, go test, and go build before merging to main."
+          },
           "python": {
             "exampleConfigFiles": [
               ".github/workflows/*",
@@ -511,6 +733,15 @@
             "notes": "Ensure CI runs linting, type checking (if used), tests, and packaging or container checks for Python services before merging.",
             "verification": "Open the CI configuration and verify there is a job or stage that runs linting, type checking (if used), tests, and any packaging or container checks before merging to main."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              ".github/workflows/*",
+              "azure-pipelines.yml"
+            ],
+            "exampleTools": [],
+            "notes": "Use 'cargo clippy', 'cargo test', 'cargo build --release' as quality gates. Consider cargo-deny for dependency auditing.",
+            "verification": "Verify CI runs cargo clippy, cargo test, and cargo build before merging to main."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".github/workflows/*",
@@ -527,7 +758,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -552,6 +785,15 @@
             "notes": "Use .editorconfig and dotnet-format to keep C# style consistent across contributors.",
             "verification": "Run the configured formatter or code style enforcement (for example, `dotnet format`) and confirm that code in the repository conforms to the defined rules."
           },
+          "go": {
+            "exampleConfigFiles": [],
+            "exampleTools": [
+              "gofmt",
+              "goimports"
+            ],
+            "notes": "Use gofmt (built-in) for formatting. goimports extends gofmt with import organization. Formatting is enforced by convention.",
+            "verification": "Run 'gofmt -d .' or 'goimports -d .' and confirm no output indicates clean formatting."
+          },
           "python": {
             "exampleConfigFiles": [
               "pyproject.toml"
@@ -562,6 +804,17 @@
             "notes": "Use black (or an equivalent opinionated formatter) and treat its output as the single source of truth for code style.",
             "verification": "Run the configured formatter (for example, `black .` or `black --check .`) and confirm it reports clean formatting on committed code and auto-fixes as expected locally."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "rustfmt.toml",
+              ".rustfmt.toml"
+            ],
+            "exampleTools": [
+              "rustfmt"
+            ],
+            "notes": "Use rustfmt (via 'cargo fmt') as the standard formatter. Configure via rustfmt.toml. Run 'cargo fmt --check' in CI.",
+            "verification": "Run 'cargo fmt --check' and confirm it reports clean formatting. Use 'cargo fmt' to auto-fix."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".prettierrc.*",
@@ -580,7 +833,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -605,6 +860,18 @@
             "notes": "Configure Lefthook or similar to run formatting and basic checks on staged files before commits.",
             "verification": "Inspect the hook configuration (for example, Lefthook or similar) and confirm it runs at least formatting and basic checks on staged changes before commits or pushes."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".pre-commit-config.yaml",
+              "lefthook.yml"
+            ],
+            "exampleTools": [
+              "pre-commit",
+              "lefthook"
+            ],
+            "notes": "Use pre-commit with go hooks for gofmt, goimports, and golangci-lint on staged files.",
+            "verification": "Inspect hooks configuration and confirm that go fmt and golangci-lint run before commits."
+          },
           "python": {
             "exampleConfigFiles": [
               ".pre-commit-config.yaml"
@@ -615,6 +882,17 @@
             "notes": "Use pre-commit to run ruff, black, and optionally mypy on staged files before committing.",
             "verification": "Inspect .pre-commit-config.yaml and confirm that hooks for linting, formatting, and optionally type checking are enabled and run on changed files before commits."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              ".pre-commit-config.yaml"
+            ],
+            "exampleTools": [
+              "pre-commit",
+              "cargo-husky"
+            ],
+            "notes": "Use pre-commit with rust hooks for cargo fmt and cargo clippy on staged files. cargo-husky is an alternative.",
+            "verification": "Inspect .pre-commit-config.yaml and confirm that hooks run cargo fmt --check and cargo clippy before commits."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".husky/",
@@ -634,7 +912,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -670,6 +950,20 @@
             ],
             "verification": ".editorconfig must exist; Directory.Build.props is optional for shared build configuration."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "go.mod"
+            ],
+            "exampleTools": [
+              "go vet",
+              "staticcheck"
+            ],
+            "notes": "Go has compile-time type checking built in. Use 'go vet' for additional static analysis. staticcheck provides enhanced type-related checks.",
+            "requiredFiles": [
+              "go.mod"
+            ],
+            "verification": "Run 'go build ./...' to verify type correctness. Use 'go vet ./...' for additional static analysis."
+          },
           "python": {
             "exampleConfigFiles": [
               "mypy.ini",
@@ -690,6 +984,19 @@
             ],
             "verification": "pyproject.toml (or mypy.ini) signals that mypy configuration is available for the repository."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Cargo.toml"
+            ],
+            "exampleTools": [
+              "rustc (built-in)"
+            ],
+            "notes": "Rust has compile-time type checking built into the language. The borrow checker enforces memory safety. No additional tooling needed for type safety.",
+            "requiredFiles": [
+              "Cargo.toml"
+            ],
+            "verification": "Run 'cargo check' or 'cargo build' to verify type correctness. All Rust code is type-checked by default."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "tsconfig.json"
@@ -713,7 +1020,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -742,6 +1051,20 @@
             ],
             "verification": "Dependency lockfile or package reference is present; security scanning is configured."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "go.sum"
+            ],
+            "exampleTools": [
+              "govulncheck",
+              "nancy"
+            ],
+            "notes": "Use govulncheck (official Go tool) for vulnerability scanning. go.sum locks dependency checksums for reproducible builds.",
+            "requiredFiles": [
+              "go.sum"
+            ],
+            "verification": "go.sum is present; run 'govulncheck ./...' to verify security scanning."
+          },
           "python": {
             "exampleConfigFiles": [
               "requirements.txt",
@@ -760,6 +1083,24 @@
             ],
             "verification": "Dependency lockfile is present; security scanning is configured in CI or project tooling."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "Cargo.lock",
+              "deny.toml"
+            ],
+            "exampleTools": [
+              "cargo-audit",
+              "cargo-deny"
+            ],
+            "notes": "Use cargo-audit for vulnerability scanning or cargo-deny for comprehensive dependency checking (licenses, advisories, bans). Cargo.lock locks versions.",
+            "optionalFiles": [
+              "deny.toml"
+            ],
+            "requiredFiles": [
+              "Cargo.lock"
+            ],
+            "verification": "Cargo.lock is present; run 'cargo audit' or 'cargo deny check' to verify security scanning."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "package-lock.json",
@@ -785,7 +1126,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -812,6 +1155,21 @@
             ],
             "verification": ".csproj files must specify TargetFramework; global.json is recommended to pin SDK version."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "go.mod",
+              ".go-version"
+            ],
+            "exampleTools": [],
+            "notes": "Specify 'go' directive in go.mod (e.g., go 1.21) to set minimum Go version. Consider .go-version for goenv users.",
+            "optionalFiles": [
+              ".go-version"
+            ],
+            "requiredFiles": [
+              "go.mod"
+            ],
+            "verification": "go.mod must contain 'go' directive specifying minimum version; .go-version is optional for local development."
+          },
           "python": {
             "exampleConfigFiles": [
               "pyproject.toml",
@@ -828,6 +1186,19 @@
             ],
             "verification": "pyproject.toml or setup.py must specify python_requires; .python-version is recommended for local development."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "rust-toolchain.toml",
+              "rust-toolchain"
+            ],
+            "exampleTools": [],
+            "notes": "Use rust-toolchain.toml to pin the Rust version (e.g., channel = 'stable' or specific version '1.75.0'). This ensures consistent builds across the team via rustup.",
+            "optionalFiles": [
+              "rust-toolchain.toml",
+              "rust-toolchain"
+            ],
+            "verification": "rust-toolchain.toml or rust-toolchain file specifies the required Rust version."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "package.json"
@@ -846,7 +1217,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -879,6 +1252,24 @@
             ],
             "verification": "README.md is present in the repository root; docs/ directory or DocFX configuration exists if applicable."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "README.md",
+              "docs/"
+            ],
+            "exampleTools": [
+              "godoc",
+              "pkgsite"
+            ],
+            "notes": "Use godoc or pkgsite for API documentation from code comments. Follow Go documentation conventions.",
+            "optionalFiles": [
+              "docs/"
+            ],
+            "requiredFiles": [
+              "README.md"
+            ],
+            "verification": "README.md is present; documentation comments exist in exported functions/types."
+          },
           "python": {
             "exampleConfigFiles": [
               "README.md",
@@ -898,6 +1289,25 @@
             ],
             "verification": "README.md is present in the repository root; docs/ directory or documentation tooling configuration exists if applicable."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "README.md",
+              "docs/"
+            ],
+            "exampleTools": [
+              "rustdoc",
+              "mdBook"
+            ],
+            "notes": "Use rustdoc (via 'cargo doc') for API documentation from doc comments. Consider mdBook for user guides and tutorials.",
+            "optionalFiles": [
+              "docs/",
+              "book.toml"
+            ],
+            "requiredFiles": [
+              "README.md"
+            ],
+            "verification": "README.md is present; run 'cargo doc' to generate API docs."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "README.md",
@@ -924,7 +1334,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -956,6 +1368,23 @@
             ],
             "verification": "LICENSE file is present in the repository root; CODE_OF_CONDUCT.md and CONTRIBUTING.md are present for contribution guidance."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "LICENSE",
+              "CODE_OF_CONDUCT.md",
+              "CONTRIBUTING.md"
+            ],
+            "exampleTools": [],
+            "notes": "Include license identifier in go.mod comments if needed. Document Go module conventions and testing requirements in CONTRIBUTING.md.",
+            "optionalFiles": [
+              "CODE_OF_CONDUCT.md",
+              "CONTRIBUTING.md"
+            ],
+            "requiredFiles": [
+              "LICENSE"
+            ],
+            "verification": "LICENSE file is present; CODE_OF_CONDUCT.md and CONTRIBUTING.md provide contribution guidance."
+          },
           "python": {
             "exampleConfigFiles": [
               "LICENSE",
@@ -973,6 +1402,23 @@
             ],
             "verification": "LICENSE file is present in the repository root; CODE_OF_CONDUCT.md and CONTRIBUTING.md are present for contribution guidance."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "LICENSE",
+              "CODE_OF_CONDUCT.md",
+              "CONTRIBUTING.md"
+            ],
+            "exampleTools": [],
+            "notes": "Include license in Cargo.toml metadata. Document cargo workspace conventions and testing requirements in CONTRIBUTING.md.",
+            "optionalFiles": [
+              "CODE_OF_CONDUCT.md",
+              "CONTRIBUTING.md"
+            ],
+            "requiredFiles": [
+              "LICENSE"
+            ],
+            "verification": "LICENSE file is present; CODE_OF_CONDUCT.md and CONTRIBUTING.md provide contribution guidance."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "LICENSE",
@@ -999,7 +1445,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -1025,6 +1473,16 @@
             "notes": "Configure structured logging for your .NET services and ensure exceptions and key events are logged with useful context.",
             "verification": "Confirm that a structured logging library (such as Serilog or NLog) is configured with an agreed sink and format, and that the application logs meaningful context for errors and key events."
           },
+          "go": {
+            "exampleConfigFiles": [],
+            "exampleTools": [
+              "slog",
+              "zap",
+              "zerolog"
+            ],
+            "notes": "Use slog (stdlib) or zap/zerolog for structured logging. Configure JSON output for production and text for development.",
+            "verification": "Confirm that a structured logging library is configured with appropriate output format and log levels."
+          },
           "python": {
             "exampleConfigFiles": [
               "logging configuration files",
@@ -1037,6 +1495,15 @@
             "notes": "Use structured logging for Python services and ensure critical paths record enough context to debug issues after the fact.",
             "verification": "Confirm that a structured logging setup (such as structlog or configured logging with JSON formatting) is in place and that critical paths log enough information to debug failures in production."
           },
+          "rust": {
+            "exampleConfigFiles": [],
+            "exampleTools": [
+              "tracing",
+              "log"
+            ],
+            "notes": "Use the tracing crate for structured logging with spans and events. Configure tracing-subscriber for output formatting.",
+            "verification": "Confirm that tracing or log crate is configured with appropriate subscriber/logger and emits structured output."
+          },
           "typescript-js": {
             "exampleConfigFiles": [],
             "exampleTools": [
@@ -1055,7 +1522,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -1082,6 +1551,16 @@
             "notes": "Create dedicated integration test projects that exercise real infrastructure or service boundaries where appropriate.",
             "verification": "Confirm there is a test project or configuration dedicated to integration or API tests and run it to verify external or cross-service interactions behave as expected."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "*_test.go"
+            ],
+            "exampleTools": [
+              "go test"
+            ],
+            "notes": "Use build tags (//go:build integration) or separate test directories for integration tests. Run with 'go test -tags=integration ./...'.",
+            "verification": "Confirm integration tests exist and run 'go test -tags=integration ./...' to verify."
+          },
           "python": {
             "exampleConfigFiles": [
               "tests/integration/"
@@ -1092,6 +1571,16 @@
             "notes": "Separate integration tests from unit tests, using fixtures to handle databases, services, or other external systems.",
             "verification": "Confirm there is a separate integration or API test suite (for example, a dedicated tests/integration directory) and run it to verify interactions with databases, services, or external systems."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "tests/"
+            ],
+            "exampleTools": [
+              "cargo test"
+            ],
+            "notes": "Use the tests/ directory for integration tests. Use #[ignore] attribute for slow tests and run with 'cargo test -- --ignored'.",
+            "verification": "Confirm tests/ directory contains integration tests and run 'cargo test' to verify cross-component flows."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "jest.config.*",
@@ -1112,7 +1601,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -1137,6 +1628,17 @@
             "notes": "Use BenchmarkDotNet or similar to track performance of critical methods or endpoints over time.",
             "verification": "Identify and run the configured performance or benchmarking suite (for example, BenchmarkDotNet) and review the output to ensure it is tracked against historical or target values."
           },
+          "go": {
+            "exampleConfigFiles": [
+              "*_test.go"
+            ],
+            "exampleTools": [
+              "go test -bench",
+              "benchstat"
+            ],
+            "notes": "Use 'go test -bench=. ./...' for benchmarks. Use benchstat to compare results across runs.",
+            "verification": "Run 'go test -bench=. ./...' and verify benchmark results are tracked over time."
+          },
           "python": {
             "exampleConfigFiles": [
               "pytest.ini",
@@ -1149,6 +1651,17 @@
             "notes": "Use simple benchmarks or profiling runs to characterize bottlenecks and watch for regressions in critical workflows.",
             "verification": "Identify and run the configured performance checks or benchmarks (for example, pytest-benchmark or cProfile-based scripts) and confirm that their results are recorded and compared over time."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "benches/"
+            ],
+            "exampleTools": [
+              "criterion",
+              "cargo bench"
+            ],
+            "notes": "Use criterion for statistical benchmarking. Create benches/ directory for benchmark files. Track results over time in CI.",
+            "verification": "Run 'cargo bench' and verify benchmark results are captured and compared against baselines."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               "lighthouserc.json"
@@ -1167,7 +1680,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -1193,6 +1708,17 @@
             "notes": "Use code metrics or Sonar analysis to flag overly complex methods and refactor them over time.",
             "verification": "Run the configured code metrics or Sonar analysis and review complexity reports for key modules, ensuring that new or changed code stays within acceptable limits."
           },
+          "go": {
+            "exampleConfigFiles": [
+              ".golangci.yml"
+            ],
+            "exampleTools": [
+              "gocyclo",
+              "golangci-lint"
+            ],
+            "notes": "Use gocyclo or golangci-lint's gocyclo linter to measure cyclomatic complexity. Configure threshold in .golangci.yml.",
+            "verification": "Run 'gocyclo' or 'golangci-lint run' and review complexity reports, ensuring new code doesn't exceed thresholds."
+          },
           "python": {
             "exampleConfigFiles": [
               "radon.cfg"
@@ -1203,6 +1729,17 @@
             "notes": "Use radon or similar tools to track complexity of Python functions and keep new code within acceptable limits.",
             "verification": "Run the configured complexity tool (for example, radon) on the codebase and review the report to ensure new or heavily changed functions are not excessively complex."
           },
+          "rust": {
+            "exampleConfigFiles": [
+              "clippy.toml"
+            ],
+            "exampleTools": [
+              "clippy",
+              "cargo-geiger"
+            ],
+            "notes": "Clippy includes cognitive complexity warnings. Use cargo-geiger for unsafe code metrics. Configure thresholds in clippy.toml.",
+            "verification": "Run 'cargo clippy' and review complexity-related warnings. Ensure new code stays within acceptable limits."
+          },
           "typescript-js": {
             "exampleConfigFiles": [
               ".eslintrc.*",
@@ -1222,7 +1759,9 @@
           "stacks": [
             "typescript-js",
             "csharp-dotnet",
-            "python"
+            "python",
+            "rust",
+            "go"
           ]
         },
         "ciHints": {
@@ -1246,6 +1785,15 @@
             "notes": "Apply accessibility tooling to ASP.NET or Blazor front-ends and review issues alongside functional testing.",
             "verification": "For web-facing apps, run the configured accessibility checks or tools against your main UI endpoints and confirm that blocking accessibility issues are addressed."
           },
+          "go": {
+            "exampleConfigFiles": [],
+            "exampleTools": [
+              "axe-core",
+              "pa11y"
+            ],
+            "notes": "For Go web apps, use headless browser-based accessibility tools to audit rendered HTML from templates.",
+            "verification": "For web-facing Go apps, run accessibility audits against key routes using axe or pa11y."
+          },
           "python": {
             "exampleConfigFiles": [],
             "exampleTools": [
@@ -1254,6 +1802,15 @@
             "notes": "Use headless browser-based tools to scan Python-backed web UIs for accessibility issues on high-traffic routes.",
             "verification": "For Python-backed web UIs, run the configured accessibility tooling (for example, pa11y or axe via a headless browser) against key routes and verify that critical issues are fixed or tracked."
           },
+          "rust": {
+            "exampleConfigFiles": [],
+            "exampleTools": [
+              "axe-core",
+              "pa11y"
+            ],
+            "notes": "For Rust web frameworks (Actix, Axum, Rocket), use headless browser-based accessibility tools to audit rendered HTML.",
+            "verification": "For web-facing Rust apps, run accessibility audits against key routes using axe or pa11y."
+          },
           "typescript-js": {
             "exampleConfigFiles": [],
             "exampleTools": [
@@ -1338,10 +1895,18 @@
       "label": "C# / .NET",
       "languageFamily": "dotnet"
     },
+    "go": {
+      "label": "Go",
+      "languageFamily": "go"
+    },
     "python": {
       "label": "Python",
       "languageFamily": "python"
     },
+    "rust": {
+      "label": "Rust",
+      "languageFamily": "rust"
+    },
     "typescript-js": {
       "label": "TypeScript / JavaScript",
       "languageFamily": "js"