@oddessentials/repo-standards 1.0.1 → 1.1.0

package/dist/config/standards.rust.json

@@ -0,0 +1,600 @@
+{
+  "checklist": {
+    "core": [
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Maintain proper .gitignore and .dockerignore files to prevent committing secrets, build artifacts, or unnecessary files.",
+        "id": "gitignore-and-dockerignore",
+        "label": "Git and Docker Ignore Files",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Run static code linting to enforce consistency and catch common issues early.",
+        "id": "linting",
+        "label": "Linting",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "test"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Provide a deterministic unit test framework with a single command to run all tests.",
+        "id": "unit-test-runner",
+        "label": "Unit Test Runner",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "build"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Provide a Dockerfile and, if applicable, a docker-compose file for local dev and CI parity.",
+        "id": "containerization",
+        "label": "Containerization (Docker / Docker Compose)",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "release"
+          },
+          "github-actions": {
+            "job": "release"
+          }
+        },
+        "description": "Use MAJOR.MINOR.PATCH versioning with clear rules and automated changelog generation based on commit history.",
+        "id": "semantic-versioning",
+        "label": "Semantic Versioning",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Enforce structured commit messages such as Conventional Commits.",
+        "id": "commit-linting",
+        "label": "Commit Linting",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "test"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Generate readable unit test and coverage reports and enforce a minimum coverage threshold (around 80%) for new or changed code.",
+        "id": "unit-test-reporter",
+        "label": "Unit Test Reporter / Coverage",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "ci"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Single CI pipeline that runs linting, formatting, type checking, tests, coverage, build, and containerization.",
+        "id": "ci-quality-gates",
+        "label": "CI Quality Gates",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Automatic code formatting to maintain a consistent style across all contributors.",
+        "id": "code-formatter",
+        "label": "Code Formatter",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Use git hooks to run linting, formatting, tests, and commit linting before changes are committed.",
+        "id": "pre-commit-hooks",
+        "label": "Pre-Commit Hooks",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Use static type checking to catch errors before runtime and enforce strictness on new code.",
+        "id": "type-checking",
+        "label": "Type Checking",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Lock dependencies and scan regularly for known vulnerabilities; fail CI on newly introduced high-severity issues.",
+        "id": "dependency-security",
+        "label": "Dependency Management & Vulnerability Scanning",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Specify required runtime/engine versions in package manifests to ensure environment stability and prevent version-related issues across development teams.",
+        "id": "runtime-version",
+        "label": "Runtime Version Specification",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "docs"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Maintain a comprehensive README and, where applicable, auto-generated API docs to support onboarding and maintainability.",
+        "id": "documentation",
+        "label": "Documentation Standards",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "governance"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Include standard governance files (LICENSE, CODE_OF_CONDUCT.md, CONTRIBUTING.md), branch protection rules, and review standards to define legal, ethical, and workflow expectations.",
+        "id": "repository-governance",
+        "label": "Repository Governance",
+        "stack": {
+          "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."
+        }
+      }
+    ],
+    "optionalEnhancements": [
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "observability"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Standardize error handling and structured logging to make debugging and production monitoring easier.",
+        "id": "observability",
+        "label": "Observability (Logging & Error Handling)",
+        "stack": {
+          "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."
+        }
+      }
+    ],
+    "recommended": [
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "test"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Test how components interact with each other and external systems, running after unit tests with more relaxed coverage thresholds.",
+        "id": "integration-testing",
+        "label": "Integration Testing",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "performance"
+          },
+          "github-actions": {
+            "job": "performance"
+          }
+        },
+        "description": "Establish performance baselines and monitor for regressions using lightweight benchmarks or audits in CI.",
+        "id": "performance-baselining",
+        "label": "Performance Baselines",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Measure cyclomatic complexity or similar metrics to keep code maintainable, starting as a warning-only check.",
+        "id": "complexity-analysis",
+        "label": "Complexity Analysis",
+        "stack": {
+          "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."
+        }
+      },
+      {
+        "ciHints": {
+          "azure-devops": {
+            "stage": "quality"
+          },
+          "github-actions": {
+            "job": "ci"
+          }
+        },
+        "description": "Run accessibility checks on web-facing components to detect critical issues and improve inclusive UX.",
+        "id": "accessibility-auditing",
+        "label": "Accessibility Auditing",
+        "stack": {
+          "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."
+        }
+      }
+    ]
+  },
+  "ciSystems": [
+    "azure-devops",
+    "github-actions"
+  ],
+  "meta": {
+    "complexityChecks": {
+      "description": "When supported by the stack, run cyclomatic complexity or similar metrics in CI as a warning-only check initially.",
+      "enabledByDefault": true
+    },
+    "defaultCoverageThreshold": 0.8,
+    "migrationGuide": [
+      {
+        "description": "Start by adding pre-commit hooks and core formatting/linting so developers get fast feedback without touching CI.",
+        "focusIds": [
+          "pre-commit-hooks",
+          "linting",
+          "code-formatter"
+        ],
+        "notes": "Keep hooks fast and focused on changed files to avoid slowing down day-to-day work.",
+        "step": 1,
+        "title": "Establish Local Safety Nets First"
+      },
+      {
+        "description": "Introduce CI quality gates that mirror local checks, but treat existing violations as warnings wherever possible.",
+        "focusIds": [
+          "ci-quality-gates",
+          "linting",
+          "code-formatter",
+          "commit-linting"
+        ],
+        "notes": "Use diff-based tools or baselines so only new violations break builds; legacy issues remain visible but non-blocking.",
+        "step": 2,
+        "title": "Mirror Local Checks in CI (Soft-Fail on Legacy)"
+      },
+      {
+        "description": "Enable type-checking, coverage thresholds, and dependency/vulnerability scanning with gradual enforcement.",
+        "focusIds": [
+          "type-checking",
+          "unit-test-runner",
+          "unit-test-reporter",
+          "dependency-security"
+        ],
+        "notes": "Pin tool and runtime versions in CI and containers to avoid flaky differences across environments.",
+        "step": 3,
+        "title": "Add Type Safety, Coverage, and Dependency Security"
+      },
+      {
+        "description": "Add documentation standards, governance files, integration testing, performance baselines, complexity analysis, accessibility auditing, and (optionally) ML-specific practices for data-heavy Python repos.",
+        "focusIds": [
+          "documentation",
+          "repository-governance",
+          "integration-testing",
+          "performance-baselining",
+          "complexity-analysis",
+          "accessibility-auditing"
+        ],
+        "notes": "Tackle recommended items in order of business value; backend-only repos can skip web-focused checks like accessibility. For AI/ML-heavy Python teams, consider extending containerization with data versioning (DVC) and unit tests with data quality checks (e.g., Great Expectations) as part of this step.",
+        "step": 4,
+        "title": "Layer in Docs, Governance, and Recommended Checks"
+      }
+    ],
+    "qualityGatePolicy": {
+      "description": "New quality checks should warn on existing code and fail CI only for violations introduced in new or changed code, to reduce friction on legacy codebases.",
+      "preferSoftFailOnLegacy": true
+    }
+  },
+  "stack": "rust",
+  "stackLabel": "Rust",
+  "version": 1
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type StackId = "typescript-js" | "csharp-dotnet" | "python";
+export type StackId = "typescript-js" | "csharp-dotnet" | "python" | "rust" | "go";
 export type CiSystem = "azure-devops" | "github-actions";
 export interface MasterJson {
     version: number;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GAAG,eAAe,GAAG,eAAe,GAAG,QAAQ,CAAC;AACnE,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAEzD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,SAAS,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,GAAG,CAAC;CAChB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GACf,eAAe,GACf,eAAe,GACf,QAAQ,GACR,MAAM,GACN,IAAI,CAAC;AACT,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAEzD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,SAAS,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,GAAG,CAAC;CAChB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oddessentials/repo-standards",
   "private": false,
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Standards and CI filtering utilities for multi-stack repository governance.",
   "type": "module",
   "scripts": {