polyglot-code-guard 0.1.0__tar.gz → 0.2.0__tar.gz

polyglot_code_guard-0.2.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: polyglot-code-guard
+Version: 0.2.0
+Summary: Fail-closed, multi-language test verification for AI-generated code.
+Author: Furox-Art
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Furox-Art/polyglot-code-guard
+Project-URL: Repository, https://github.com/Furox-Art/polyglot-code-guard
+Project-URL: Issues, https://github.com/Furox-Art/polyglot-code-guard/issues
+Keywords: testing,code-verification,polyglot,ai-generated-code,quality-gate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# Polyguard
+
+**A fail-closed verification gate for AI-generated code across multiple programming languages.**
+
+Polyguard discovers supported project types, checks that a real test suite is present, executes the project's test/build commands, and reports a one-word verdict by default. It reports **PASS** only when every detected or explicitly required language has test evidence and every configured command exits successfully.
+
+## Install
+
+```bash
+python -m pip install --upgrade polyglot-code-guard
+```
+
+## Run
+
+From the target repository:
+
+```bash
+polyguard verify
+```
+
+Normal output is exactly one verdict:
+
+```text
+PASS
+```
+
+or:
+
+```text
+FAIL
+```
+
+Useful diagnostic modes:
+
+```bash
+polyguard verify --details
+polyguard verify --json
+polyguard verify --path ./my-project --timeout 180
+polyguard verify --config ./ci/polyguard.toml
+polyguard --version
+```
+
+Exit code is **0** for PASS and **1** for FAIL. A missing project, malformed configuration, missing test suite, missing toolchain, command error, or timeout fails closed.
+
+## Configure project-specific test commands
+
+Automatic detection is useful for conventional projects, but real repositories often use custom layouts and test runners. Put a `.polyguard.toml` file in the project root, or pass a file with `--config`.
+
+Example:
+
+```toml
+[project]
+# Every listed language is required for an overall PASS.
+languages = ["python", "rust"]
+
+[checks.python]
+commands = [
+  ["python3", "-m", "compileall", "-q", "src"],
+  ["python3", "-m", "pytest", "-q"],
+]
+test_patterns = ["tests/test_*.py", "tests/**/*.py"]
+
+[checks.rust]
+commands = [["cargo", "test", "--all-targets"]]
+test_patterns = ["tests/**/*.rs", "src/**/*.rs"]
+```
+
+Rules:
+- `commands` is a non-empty list of argument arrays. Commands are launched without a shell.
+- `test_patterns` must match at least one file inside the project root.
+- A language under `[project].languages` is mandatory even if automatic detection misses it.
+- A custom check overrides the built-in commands and test-file heuristic for that language.
+- Patterns containing parent-directory traversal (`..`) are rejected.
+- Do not use a command that merely prints success; it must execute the actual test suite.
+
+A starter file is available as `.polyguard.example.toml`.
+
+## Initial built-in language support
+
+| Language | Default command |
+| --- | --- |
+| Python | `python -m compileall`, then `python -m pytest` |
+| Rust | `cargo test --all-targets` |
+| Go | `go test ./...` |
+| JavaScript / TypeScript | `npm test`; TypeScript also runs `tsc --noEmit` when configured |
+| Java | Maven `test` or Gradle `test` |
+| C# | `dotnet test` |
+| PHP | PHPUnit |
+| Ruby | RSpec or Rake test |
+| Swift | `swift test` |
+| C / C++ | CMake build and CTest |
+
+Automatic test evidence is detected using language-specific test names, declarations, or annotations. For unconventional frameworks, use `.polyguard.toml` to define the actual test commands and test file patterns.
+
+## AI coding-agent skill
+
+The repository contains `SKILL.md`. Add it to the coding agent's instruction/skills directory and require the agent to run:
+
+```bash
+polyguard verify --path . --details
+```
+
+Agents must not claim successful verification unless the command exits 0 and returns PASS. If any language fails, the overall result is FAIL. Agents must not delete, skip, or weaken tests to obtain PASS.
+
+## Important limitations and security
+
+Polyguard is a test execution gate, **not a formal proof of correctness**. PASS means the configured commands completed successfully; it does not guarantee comprehensive test coverage, correct requirements, or absence of defects. Tests can be weak or misleading. Test quality remains a separate responsibility.
+
+The verifier executes project build scripts, package managers, and test commands. Treat repositories and dependencies as untrusted. Run them in a disposable container or VM without credentials, privileged access, or sensitive host mounts. Polyguard does not itself provide operating-system isolation.
+
+Built-in language recognition is intentionally conservative. Use explicit configuration for monorepos, non-standard directory structures, custom test frameworks, or multiple packages in one repository.
+
+## Development
+
+```bash
+python -m pip install -e ".[test]"
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+## Publishing
+
+The GitHub Actions workflow builds the distributions and publishes using PyPI Trusted Publishing. Configure the PyPI publisher for:
+- Owner: `Furox-Art`
+- Repository: `polyglot-code-guard`
+- Workflow: `publish.yml`
+- Environment: `pypi`
+
+## License
+
+MIT

polyglot_code_guard-0.2.0/README.md

@@ -0,0 +1,132 @@
+# Polyguard
+
+**A fail-closed verification gate for AI-generated code across multiple programming languages.**
+
+Polyguard discovers supported project types, checks that a real test suite is present, executes the project's test/build commands, and reports a one-word verdict by default. It reports **PASS** only when every detected or explicitly required language has test evidence and every configured command exits successfully.
+
+## Install
+
+```bash
+python -m pip install --upgrade polyglot-code-guard
+```
+
+## Run
+
+From the target repository:
+
+```bash
+polyguard verify
+```
+
+Normal output is exactly one verdict:
+
+```text
+PASS
+```
+
+or:
+
+```text
+FAIL
+```
+
+Useful diagnostic modes:
+
+```bash
+polyguard verify --details
+polyguard verify --json
+polyguard verify --path ./my-project --timeout 180
+polyguard verify --config ./ci/polyguard.toml
+polyguard --version
+```
+
+Exit code is **0** for PASS and **1** for FAIL. A missing project, malformed configuration, missing test suite, missing toolchain, command error, or timeout fails closed.
+
+## Configure project-specific test commands
+
+Automatic detection is useful for conventional projects, but real repositories often use custom layouts and test runners. Put a `.polyguard.toml` file in the project root, or pass a file with `--config`.
+
+Example:
+
+```toml
+[project]
+# Every listed language is required for an overall PASS.
+languages = ["python", "rust"]
+
+[checks.python]
+commands = [
+  ["python3", "-m", "compileall", "-q", "src"],
+  ["python3", "-m", "pytest", "-q"],
+]
+test_patterns = ["tests/test_*.py", "tests/**/*.py"]
+
+[checks.rust]
+commands = [["cargo", "test", "--all-targets"]]
+test_patterns = ["tests/**/*.rs", "src/**/*.rs"]
+```
+
+Rules:
+- `commands` is a non-empty list of argument arrays. Commands are launched without a shell.
+- `test_patterns` must match at least one file inside the project root.
+- A language under `[project].languages` is mandatory even if automatic detection misses it.
+- A custom check overrides the built-in commands and test-file heuristic for that language.
+- Patterns containing parent-directory traversal (`..`) are rejected.
+- Do not use a command that merely prints success; it must execute the actual test suite.
+
+A starter file is available as `.polyguard.example.toml`.
+
+## Initial built-in language support
+
+| Language | Default command |
+| --- | --- |
+| Python | `python -m compileall`, then `python -m pytest` |
+| Rust | `cargo test --all-targets` |
+| Go | `go test ./...` |
+| JavaScript / TypeScript | `npm test`; TypeScript also runs `tsc --noEmit` when configured |
+| Java | Maven `test` or Gradle `test` |
+| C# | `dotnet test` |
+| PHP | PHPUnit |
+| Ruby | RSpec or Rake test |
+| Swift | `swift test` |
+| C / C++ | CMake build and CTest |
+
+Automatic test evidence is detected using language-specific test names, declarations, or annotations. For unconventional frameworks, use `.polyguard.toml` to define the actual test commands and test file patterns.
+
+## AI coding-agent skill
+
+The repository contains `SKILL.md`. Add it to the coding agent's instruction/skills directory and require the agent to run:
+
+```bash
+polyguard verify --path . --details
+```
+
+Agents must not claim successful verification unless the command exits 0 and returns PASS. If any language fails, the overall result is FAIL. Agents must not delete, skip, or weaken tests to obtain PASS.
+
+## Important limitations and security
+
+Polyguard is a test execution gate, **not a formal proof of correctness**. PASS means the configured commands completed successfully; it does not guarantee comprehensive test coverage, correct requirements, or absence of defects. Tests can be weak or misleading. Test quality remains a separate responsibility.
+
+The verifier executes project build scripts, package managers, and test commands. Treat repositories and dependencies as untrusted. Run them in a disposable container or VM without credentials, privileged access, or sensitive host mounts. Polyguard does not itself provide operating-system isolation.
+
+Built-in language recognition is intentionally conservative. Use explicit configuration for monorepos, non-standard directory structures, custom test frameworks, or multiple packages in one repository.
+
+## Development
+
+```bash
+python -m pip install -e ".[test]"
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+## Publishing
+
+The GitHub Actions workflow builds the distributions and publishes using PyPI Trusted Publishing. Configure the PyPI publisher for:
+- Owner: `Furox-Art`
+- Repository: `polyglot-code-guard`
+- Workflow: `publish.yml`
+- Environment: `pypi`
+
+## License
+
+MIT

{polyglot_code_guard-0.1.0 → polyglot_code_guard-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyglot-code-guard"
-version = "0.1.0"
+version = "0.2.0"
 description = "Fail-closed, multi-language test verification for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,7 +18,7 @@ classifiers = [
   "Programming Language :: Python :: 3",
   "Topic :: Software Development :: Testing",
 ]
-dependencies = []
+dependencies = ["tomli>=2; python_version < '3.11'"]
 
 [project.optional-dependencies]
 test = ["pytest>=8.0"]

polyglot_code_guard-0.2.0/src/polyglot_code_guard.egg-info/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: polyglot-code-guard
+Version: 0.2.0
+Summary: Fail-closed, multi-language test verification for AI-generated code.
+Author: Furox-Art
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Furox-Art/polyglot-code-guard
+Project-URL: Repository, https://github.com/Furox-Art/polyglot-code-guard
+Project-URL: Issues, https://github.com/Furox-Art/polyglot-code-guard/issues
+Keywords: testing,code-verification,polyglot,ai-generated-code,quality-gate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# Polyguard
+
+**A fail-closed verification gate for AI-generated code across multiple programming languages.**
+
+Polyguard discovers supported project types, checks that a real test suite is present, executes the project's test/build commands, and reports a one-word verdict by default. It reports **PASS** only when every detected or explicitly required language has test evidence and every configured command exits successfully.
+
+## Install
+
+```bash
+python -m pip install --upgrade polyglot-code-guard
+```
+
+## Run
+
+From the target repository:
+
+```bash
+polyguard verify
+```
+
+Normal output is exactly one verdict:
+
+```text
+PASS
+```
+
+or:
+
+```text
+FAIL
+```
+
+Useful diagnostic modes:
+
+```bash
+polyguard verify --details
+polyguard verify --json
+polyguard verify --path ./my-project --timeout 180
+polyguard verify --config ./ci/polyguard.toml
+polyguard --version
+```
+
+Exit code is **0** for PASS and **1** for FAIL. A missing project, malformed configuration, missing test suite, missing toolchain, command error, or timeout fails closed.
+
+## Configure project-specific test commands
+
+Automatic detection is useful for conventional projects, but real repositories often use custom layouts and test runners. Put a `.polyguard.toml` file in the project root, or pass a file with `--config`.
+
+Example:
+
+```toml
+[project]
+# Every listed language is required for an overall PASS.
+languages = ["python", "rust"]
+
+[checks.python]
+commands = [
+  ["python3", "-m", "compileall", "-q", "src"],
+  ["python3", "-m", "pytest", "-q"],
+]
+test_patterns = ["tests/test_*.py", "tests/**/*.py"]
+
+[checks.rust]
+commands = [["cargo", "test", "--all-targets"]]
+test_patterns = ["tests/**/*.rs", "src/**/*.rs"]
+```
+
+Rules:
+- `commands` is a non-empty list of argument arrays. Commands are launched without a shell.
+- `test_patterns` must match at least one file inside the project root.
+- A language under `[project].languages` is mandatory even if automatic detection misses it.
+- A custom check overrides the built-in commands and test-file heuristic for that language.
+- Patterns containing parent-directory traversal (`..`) are rejected.
+- Do not use a command that merely prints success; it must execute the actual test suite.
+
+A starter file is available as `.polyguard.example.toml`.
+
+## Initial built-in language support
+
+| Language | Default command |
+| --- | --- |
+| Python | `python -m compileall`, then `python -m pytest` |
+| Rust | `cargo test --all-targets` |
+| Go | `go test ./...` |
+| JavaScript / TypeScript | `npm test`; TypeScript also runs `tsc --noEmit` when configured |
+| Java | Maven `test` or Gradle `test` |
+| C# | `dotnet test` |
+| PHP | PHPUnit |
+| Ruby | RSpec or Rake test |
+| Swift | `swift test` |
+| C / C++ | CMake build and CTest |
+
+Automatic test evidence is detected using language-specific test names, declarations, or annotations. For unconventional frameworks, use `.polyguard.toml` to define the actual test commands and test file patterns.
+
+## AI coding-agent skill
+
+The repository contains `SKILL.md`. Add it to the coding agent's instruction/skills directory and require the agent to run:
+
+```bash
+polyguard verify --path . --details
+```
+
+Agents must not claim successful verification unless the command exits 0 and returns PASS. If any language fails, the overall result is FAIL. Agents must not delete, skip, or weaken tests to obtain PASS.
+
+## Important limitations and security
+
+Polyguard is a test execution gate, **not a formal proof of correctness**. PASS means the configured commands completed successfully; it does not guarantee comprehensive test coverage, correct requirements, or absence of defects. Tests can be weak or misleading. Test quality remains a separate responsibility.
+
+The verifier executes project build scripts, package managers, and test commands. Treat repositories and dependencies as untrusted. Run them in a disposable container or VM without credentials, privileged access, or sensitive host mounts. Polyguard does not itself provide operating-system isolation.
+
+Built-in language recognition is intentionally conservative. Use explicit configuration for monorepos, non-standard directory structures, custom test frameworks, or multiple packages in one repository.
+
+## Development
+
+```bash
+python -m pip install -e ".[test]"
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+## Publishing
+
+The GitHub Actions workflow builds the distributions and publishes using PyPI Trusted Publishing. Configure the PyPI publisher for:
+- Owner: `Furox-Art`
+- Repository: `polyglot-code-guard`
+- Workflow: `publish.yml`
+- Environment: `pypi`
+
+## License
+
+MIT

polyglot_code_guard-0.2.0/src/polyglot_code_guard.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[:python_version < "3.11"]
+tomli>=2
+
+[test]
+pytest>=8.0

polyglot_code_guard-0.2.0/src/polyguard/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: polyglot-code-verification
+description: Verify AI-generated code with real project test commands and fail closed when tests are missing or fail.
+---
+
+# Polyglot Code Verification
+
+Use this skill whenever code is generated, changed, refactored, or described as complete.
+
+## Required workflow
+
+1. Identify all languages, build systems, packages, and project roots touched by the change.
+2. Review the user's requirements and create or update tests for normal behavior, edge cases, invalid inputs, error paths, and regressions.
+3. For conventional repositories, run `polyguard verify --path . --details`.
+4. For a custom layout or test runner, add a `.polyguard.toml` with explicit commands and test file patterns. Never use a command that simply prints success.
+5. Run the complete configured test suite. Do not omit a detected or required language.
+6. If any command fails, the toolchain is missing, tests cannot be found, configuration is invalid, or a timeout occurs, the final verdict is FAIL.
+7. Fix the implementation or tests and rerun all checks. Never delete, skip, weaken, or rewrite a valid test merely to obtain PASS.
+8. Retain command output and the JSON report when the user requests inspectable evidence.
+
+## Output contract
+
+- All detected and required language checks pass: PASS
+- Any failure or incomplete verification: FAIL
+
+The CLI exits 0 only for PASS and 1 for FAIL. The default output is exactly one word; use `--details` or `--json` for diagnostics.
+
+## Security
+
+The verifier executes build tools, package managers, scripts, and tests from the target repository. Run untrusted code in a disposable container or isolated virtual machine without secrets, privileged access, or sensitive host mounts. Polyguard is not an operating-system sandbox.
+
+## Scope
+
+Built-in support: Python, Rust, Go, JavaScript/TypeScript, Java, C#, PHP, Ruby, Swift, and C/C++ with CMake. Use project configuration for unconventional layouts, custom test runners, and monorepos.

{polyglot_code_guard-0.1.0 → polyglot_code_guard-0.2.0}/src/polyguard/__init__.py

@@ -1,3 +1,3 @@
 """Polyguard: fail-closed verification for multi-language projects."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{polyglot_code_guard-0.1.0 → polyglot_code_guard-0.2.0}/src/polyguard/cli.py

@@ -5,27 +5,28 @@ from __future__ import annotations
 import argparse
 from pathlib import Path
 
+from . import __version__
 from .runner import render_report, run_checks
 
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="polyguard",
-        description="Run available language test suites and fail closed when proof is missing.",
+        description="Run project test suites and fail closed when verification is incomplete.",
     )
     parser.add_argument("verify", nargs="?", choices=["verify"], default="verify")
     parser.add_argument("--path", default=".", help="Project directory to verify.")
+    parser.add_argument("--config", help="Path to a Polyguard TOML config (default: .polyguard.toml in project root).")
     parser.add_argument("--timeout", type=int, default=120, help="Timeout per command in seconds.")
     parser.add_argument("--details", action="store_true", help="Show per-language diagnostics.")
     parser.add_argument("--json", action="store_true", help="Emit a machine-readable JSON report.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     return parser
 
 
 def main() -> int:
     args = build_parser().parse_args()
-    if args.timeout < 1:
-        raise SystemExit("--timeout must be at least 1 second.")
-    report = run_checks(Path(args.path), timeout=args.timeout)
+    report = run_checks(Path(args.path), timeout=args.timeout, config_path=args.config)
     print(render_report(report, details=args.details, as_json=args.json))
     return 0 if report["status"] == "PASS" else 1