ai-test-loop 1.1.0__tar.gz

ai_test_loop-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Samuel Medeiros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_test_loop-1.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md LICENSE
+include ai_test_loop/scripts/*.py

ai_test_loop-1.1.0/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: ai-test-loop
+Version: 1.1.0
+Summary: Deterministic critic for AI agents: runs weighed checks for real, scores 0-100 and blocks delivery below the threshold.
+Author: Samuel Medeiros
+License: MIT
+Project-URL: Homepage, https://skills.seu.pet/en/p/ai-test-loop?utm_source=pypi&utm_medium=readme&utm_campaign=ai-test-loop
+Project-URL: Repository, https://github.com/Samuelfmedeiros/ai-test-loop
+Project-URL: Changelog, https://github.com/Samuelfmedeiros/ai-test-loop/releases
+Keywords: mcp,ai-agent,ai-agents,llm,testing,test-loop,quality-gate,delivery-gate,critic,claude-code,cursor,code-review
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ai-test-loop
+
+**Your agent grades its own homework.** This makes that impossible: a critic script runs real checks,
+scores the artifact 0–100, and a fail-closed gate blocks delivery below the threshold.
+
+```bash
+npx ai-test-loop --config loop.json     # zero install, no Python needed
+```
+
+Real output, not a mockup:
+
+```
+  PASS  unit tests                   w=40     12.4s  41 passed in 12.31s
+  FAIL  build                        w=20      3.1s  error TS2307: Cannot find module './api'
+  PASS  no secrets                   w=15      0.8s  no leaks found
+SCORE=75.0
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+```
+
+> **Want this wired into your repo, with the visual-diff gate and the delivery report?**
+> The ready-made packs are at **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+> — or grab the free runner first and see if the loop earns its place.
+
+No API keys, no dependencies, no model calls. The runner is deliberately dumb: exit codes and
+optional output patterns decide pass/fail. The model never gets to *say* the work is good — it has
+to *show* it.
+
+---
+
+## Install
+
+Same package name everywhere. Both registries, same name:
+
+```bash
+npx ai-test-loop --help          # Node 18+ — nothing to install
+pip install ai-test-loop         # Python 3.9+ — same engine (PyPI)
+```
+
+`npx` is the fastest path: it downloads and runs in about five seconds, no virtualenv, no Python.
+The npm package carries a Node port of the runner; the PyPI package carries the Python one. Both
+print the same `SCORE=` / `GAPS=` / `EVIDENCE=` contract, so the gate you run locally is the gate CI
+runs.
+
+Verify with a dry run — it lists the checks and weights without executing anything:
+
+```bash
+npx ai-test-loop --config templates/loop.example.json --dry-run
+```
+
+> Older docs and articles mention `pip install agent-test-loop`. That is the previous PyPI name and
+> still works — it is the same engine, kept as a mirror so existing installs do not break. New code
+> should use `ai-test-loop`.
+
+## The problem
+
+Ask an agent "is this done?" and it answers about its own reasoning. The same context that produced
+the artifact also decides it is correct, so real defects survive to delivery:
+
+- a handler that is never called (tests pass, feature dead)
+- a test that passes because it asserts nothing
+- a page that breaks only at mobile width
+- a migration that works on the author's data and nowhere else
+- a "fix" that reverted a config someone changed on purpose
+
+Running "one more review pass" does not help, because the reviewer and the builder are the same
+process. Separating them is the whole trick.
+
+## Quickstart
+
+```bash
+npx ai-test-loop --config loop.json
+```
+
+Describe your checks once — name, command, weight:
+
+```json
+{
+  "name": "my-project",
+  "threshold": 85,
+  "max_rounds": 8,
+  "checks": [
+    {"name": "unit tests", "cmd": "pytest -q", "weight": 35, "timeout_s": 900},
+    {"name": "type check", "cmd": "mypy src", "weight": 10},
+    {"name": "build",      "cmd": "npm run build", "weight": 20},
+    {"name": "api up",     "cmd": "curl -sS 127.0.0.1:8000/health", "weight": 15,
+     "must_match": "\"status\"\\s*:\\s*\"ok\""},
+    {"name": "no secrets", "cmd": "gitleaks detect --no-banner", "weight": 20,
+     "fail_if_output_matches": "leaks found: [1-9]", "required": true}
+  ]
+}
+```
+
+Output is machine-readable, so the *agent* can act on it and a CI job can gate on it:
+
+```
+SCORE=75.0
+THRESHOLD=85
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+EVIDENCE=loop-report-r1.json
+```
+
+Exit code is `0` when the gate passes and `1` when it fails — so `npx ai-test-loop --config
+loop.json` is a valid CI step on its own, with no parsing.
+
+Fix the **single largest** gap, run `--round 2`, repeat. Cap the rounds (8 is plenty): if the score
+never converges, the check set is wrong, not the code.
+
+## Config reference
+
+| Key | Meaning |
+|---|---|
+| `cmd` | (required) shell command, run with `bash -o pipefail -c` |
+| `weight` | (required) points; weights are normalised, they need not sum to 100 |
+| `timeout_s` | default 900 — a timeout is a **FAIL**, never a skip |
+| `expect_exit` | default 0 |
+| `must_match` | regex that must appear in the combined stdout+stderr |
+| `fail_if_output_matches` | regex that fails the check when it appears |
+| `required` | default `true`; `false` scores 0 but reports as a non-blocking gap |
+| `cwd` | working directory for that check |
+
+`bash -o pipefail` is not decoration: without it `pytest | tail` returns tail's exit code (0), so a
+failing suite scores as passing. That is the most common false green in runners like this one.
+
+## The four roles (never merge them)
+
+| Role | Who | Job |
+|---|---|---|
+| Orchestrator | the agent running the task | picks checks, runs rounds, owns the report |
+| Builder | the agent/model that wrote the artifact | fixes one class of gap per pass |
+| Critic | this script + your checks | runs real commands, returns score + gaps |
+| Reviewer | a **separate** context/model | audits critic and builder, can reopen the loop |
+
+Rule zero: builder ≠ critic ≠ reviewer. If one context does all three, the loop is theatre.
+
+## Three rules that make it honest
+
+1. **Every point is earned by a command that actually ran.** No points for "read the code". The
+   report stores the raw output next to each score.
+2. **`NOT VERIFIABLE` is not a pass.** If a check cannot run (missing device, no network, jail), it
+   scores 0 and the report says why. Silent skips are how a green board lies.
+3. **The security gate is fail-closed.** A secret in the diff or history, a high-severity SAST
+   finding, or an auth/path-traversal/injection issue found in review blocks delivery **even with a
+   perfect score**. An inconclusive answer counts as blocked, never as pass.
+
+## Reviewer panel
+
+For anything other people will use, ask 2–3 specialists instead of one generalist — quality and
+security always, performance only if there is a build or runtime cost, UX only if there is a
+user-facing surface. Each returns strict JSON:
+
+```json
+{"parecer":"CONCORDO|DISCORDO","nota":0-100,"gaps":["..."],"texto":"one paragraph with evidence"}
+```
+
+Consensus → deliver. Majority disagree → reopen the loop with the combined gaps. Prompt in
+`references/reviewer-prompt.md`, starting rubric in `references/scoring-rubric.md`.
+
+## Telemetry (opt-out, and what it is not)
+
+The `npx ai-test-loop` wrapper sends **one anonymous event per run** so the project knows whether
+the tool is actually used — downloads alone are not usage (npm counts mirrors and CI).
+
+What is sent: event type (`run`/`help`/`version`/`erro`), package version, Node major, OS name,
+duration in ms, and — only on a real run — the final score and the number of gaps.
+
+What is **never** sent: your IP (not logged server-side), e-mail, project path, file names, the
+content of your checks, the command output, or anything from your code.
+
+The install id is a random UUID written to `~/.ai-test-loop/telemetry-id` once. It counts machines,
+not people. Delete that file and you are a new machine.
+
+```bash
+ai-test-loop --no-telemetry ...          # that run only
+export AI_TEST_LOOP_NO_TELEMETRY=1       # permanently, in your shell profile
+export DO_NOT_TRACK=1                    # the ecosystem-wide convention, also respected
+# CI=1 is detected automatically: pipelines are not people
+```
+
+Telemetry never blocks and never waits: if the network is down the CLI runs exactly the same.
+
+## When not to use it
+
+Throwaway exploration, spike branches, and one-line answers where the cost of the loop exceeds the
+cost of being wrong. It is for artifacts a human will rely on.
+
+## Files
+
+| Path | What |
+|---|---|
+| `bin/cli.js` | the `npx` entry point (wrapper + telemetry) |
+| `scripts/loop_runner.js` | the deterministic critic, Node port — zero dependencies |
+| `scripts/loop_runner.py` | the same critic in Python (used by the pip package) |
+| `scripts/selftest.js` | 22 assertions covering every way a check can fail — `npm test` |
+| `SKILL.md` | the loop, the scoring rules, the fail-closed gate — drop it in your agent's skills dir |
+| `references/reviewer-prompt.md` | independent-review prompt, strict JSON output |
+| `references/scoring-rubric.md` | starting weights |
+| `templates/loop.example.json` | config with the usual check set |
+
+`npm test` runs the selftest. It needs nothing but node.
+
+## Get the full pack
+
+This repo is the free, complete tool. The store has the ready-made packs for the cases where
+writing the checks is the slow part — CI gates, visual regression, MCP servers, MLOps guards:
+
+- Free download / e-mail delivery: **https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Full pack: **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Catalog: **https://skills.seu.pet/?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Want it installed and wired into your repo: **https://skills.seu.pet/servico?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+
+## License
+
+MIT — see `LICENSE`. Use it commercially, fork it, ship it.
+
+---
+
+### Em português
+
+O loop de teste para agentes: o construtor não assina o próprio trabalho. Um crítico roda checagens
+de verdade, dá nota 0–100 e barra a entrega abaixo do limite.
+
+```bash
+npx ai-test-loop --config loop.json   # não precisa de Python
+```
+
+Sem chave de API, sem dependência, sem chamada de modelo. Versão com entrega por e-mail e os packs
+prontos: https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop

ai_test_loop-1.1.0/README.md

@@ -0,0 +1,229 @@
+# ai-test-loop
+
+**Your agent grades its own homework.** This makes that impossible: a critic script runs real checks,
+scores the artifact 0–100, and a fail-closed gate blocks delivery below the threshold.
+
+```bash
+npx ai-test-loop --config loop.json     # zero install, no Python needed
+```
+
+Real output, not a mockup:
+
+```
+  PASS  unit tests                   w=40     12.4s  41 passed in 12.31s
+  FAIL  build                        w=20      3.1s  error TS2307: Cannot find module './api'
+  PASS  no secrets                   w=15      0.8s  no leaks found
+SCORE=75.0
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+```
+
+> **Want this wired into your repo, with the visual-diff gate and the delivery report?**
+> The ready-made packs are at **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+> — or grab the free runner first and see if the loop earns its place.
+
+No API keys, no dependencies, no model calls. The runner is deliberately dumb: exit codes and
+optional output patterns decide pass/fail. The model never gets to *say* the work is good — it has
+to *show* it.
+
+---
+
+## Install
+
+Same package name everywhere. Both registries, same name:
+
+```bash
+npx ai-test-loop --help          # Node 18+ — nothing to install
+pip install ai-test-loop         # Python 3.9+ — same engine (PyPI)
+```
+
+`npx` is the fastest path: it downloads and runs in about five seconds, no virtualenv, no Python.
+The npm package carries a Node port of the runner; the PyPI package carries the Python one. Both
+print the same `SCORE=` / `GAPS=` / `EVIDENCE=` contract, so the gate you run locally is the gate CI
+runs.
+
+Verify with a dry run — it lists the checks and weights without executing anything:
+
+```bash
+npx ai-test-loop --config templates/loop.example.json --dry-run
+```
+
+> Older docs and articles mention `pip install agent-test-loop`. That is the previous PyPI name and
+> still works — it is the same engine, kept as a mirror so existing installs do not break. New code
+> should use `ai-test-loop`.
+
+## The problem
+
+Ask an agent "is this done?" and it answers about its own reasoning. The same context that produced
+the artifact also decides it is correct, so real defects survive to delivery:
+
+- a handler that is never called (tests pass, feature dead)
+- a test that passes because it asserts nothing
+- a page that breaks only at mobile width
+- a migration that works on the author's data and nowhere else
+- a "fix" that reverted a config someone changed on purpose
+
+Running "one more review pass" does not help, because the reviewer and the builder are the same
+process. Separating them is the whole trick.
+
+## Quickstart
+
+```bash
+npx ai-test-loop --config loop.json
+```
+
+Describe your checks once — name, command, weight:
+
+```json
+{
+  "name": "my-project",
+  "threshold": 85,
+  "max_rounds": 8,
+  "checks": [
+    {"name": "unit tests", "cmd": "pytest -q", "weight": 35, "timeout_s": 900},
+    {"name": "type check", "cmd": "mypy src", "weight": 10},
+    {"name": "build",      "cmd": "npm run build", "weight": 20},
+    {"name": "api up",     "cmd": "curl -sS 127.0.0.1:8000/health", "weight": 15,
+     "must_match": "\"status\"\\s*:\\s*\"ok\""},
+    {"name": "no secrets", "cmd": "gitleaks detect --no-banner", "weight": 20,
+     "fail_if_output_matches": "leaks found: [1-9]", "required": true}
+  ]
+}
+```
+
+Output is machine-readable, so the *agent* can act on it and a CI job can gate on it:
+
+```
+SCORE=75.0
+THRESHOLD=85
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+EVIDENCE=loop-report-r1.json
+```
+
+Exit code is `0` when the gate passes and `1` when it fails — so `npx ai-test-loop --config
+loop.json` is a valid CI step on its own, with no parsing.
+
+Fix the **single largest** gap, run `--round 2`, repeat. Cap the rounds (8 is plenty): if the score
+never converges, the check set is wrong, not the code.
+
+## Config reference
+
+| Key | Meaning |
+|---|---|
+| `cmd` | (required) shell command, run with `bash -o pipefail -c` |
+| `weight` | (required) points; weights are normalised, they need not sum to 100 |
+| `timeout_s` | default 900 — a timeout is a **FAIL**, never a skip |
+| `expect_exit` | default 0 |
+| `must_match` | regex that must appear in the combined stdout+stderr |
+| `fail_if_output_matches` | regex that fails the check when it appears |
+| `required` | default `true`; `false` scores 0 but reports as a non-blocking gap |
+| `cwd` | working directory for that check |
+
+`bash -o pipefail` is not decoration: without it `pytest | tail` returns tail's exit code (0), so a
+failing suite scores as passing. That is the most common false green in runners like this one.
+
+## The four roles (never merge them)
+
+| Role | Who | Job |
+|---|---|---|
+| Orchestrator | the agent running the task | picks checks, runs rounds, owns the report |
+| Builder | the agent/model that wrote the artifact | fixes one class of gap per pass |
+| Critic | this script + your checks | runs real commands, returns score + gaps |
+| Reviewer | a **separate** context/model | audits critic and builder, can reopen the loop |
+
+Rule zero: builder ≠ critic ≠ reviewer. If one context does all three, the loop is theatre.
+
+## Three rules that make it honest
+
+1. **Every point is earned by a command that actually ran.** No points for "read the code". The
+   report stores the raw output next to each score.
+2. **`NOT VERIFIABLE` is not a pass.** If a check cannot run (missing device, no network, jail), it
+   scores 0 and the report says why. Silent skips are how a green board lies.
+3. **The security gate is fail-closed.** A secret in the diff or history, a high-severity SAST
+   finding, or an auth/path-traversal/injection issue found in review blocks delivery **even with a
+   perfect score**. An inconclusive answer counts as blocked, never as pass.
+
+## Reviewer panel
+
+For anything other people will use, ask 2–3 specialists instead of one generalist — quality and
+security always, performance only if there is a build or runtime cost, UX only if there is a
+user-facing surface. Each returns strict JSON:
+
+```json
+{"parecer":"CONCORDO|DISCORDO","nota":0-100,"gaps":["..."],"texto":"one paragraph with evidence"}
+```
+
+Consensus → deliver. Majority disagree → reopen the loop with the combined gaps. Prompt in
+`references/reviewer-prompt.md`, starting rubric in `references/scoring-rubric.md`.
+
+## Telemetry (opt-out, and what it is not)
+
+The `npx ai-test-loop` wrapper sends **one anonymous event per run** so the project knows whether
+the tool is actually used — downloads alone are not usage (npm counts mirrors and CI).
+
+What is sent: event type (`run`/`help`/`version`/`erro`), package version, Node major, OS name,
+duration in ms, and — only on a real run — the final score and the number of gaps.
+
+What is **never** sent: your IP (not logged server-side), e-mail, project path, file names, the
+content of your checks, the command output, or anything from your code.
+
+The install id is a random UUID written to `~/.ai-test-loop/telemetry-id` once. It counts machines,
+not people. Delete that file and you are a new machine.
+
+```bash
+ai-test-loop --no-telemetry ...          # that run only
+export AI_TEST_LOOP_NO_TELEMETRY=1       # permanently, in your shell profile
+export DO_NOT_TRACK=1                    # the ecosystem-wide convention, also respected
+# CI=1 is detected automatically: pipelines are not people
+```
+
+Telemetry never blocks and never waits: if the network is down the CLI runs exactly the same.
+
+## When not to use it
+
+Throwaway exploration, spike branches, and one-line answers where the cost of the loop exceeds the
+cost of being wrong. It is for artifacts a human will rely on.
+
+## Files
+
+| Path | What |
+|---|---|
+| `bin/cli.js` | the `npx` entry point (wrapper + telemetry) |
+| `scripts/loop_runner.js` | the deterministic critic, Node port — zero dependencies |
+| `scripts/loop_runner.py` | the same critic in Python (used by the pip package) |
+| `scripts/selftest.js` | 22 assertions covering every way a check can fail — `npm test` |
+| `SKILL.md` | the loop, the scoring rules, the fail-closed gate — drop it in your agent's skills dir |
+| `references/reviewer-prompt.md` | independent-review prompt, strict JSON output |
+| `references/scoring-rubric.md` | starting weights |
+| `templates/loop.example.json` | config with the usual check set |
+
+`npm test` runs the selftest. It needs nothing but node.
+
+## Get the full pack
+
+This repo is the free, complete tool. The store has the ready-made packs for the cases where
+writing the checks is the slow part — CI gates, visual regression, MCP servers, MLOps guards:
+
+- Free download / e-mail delivery: **https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Full pack: **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Catalog: **https://skills.seu.pet/?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Want it installed and wired into your repo: **https://skills.seu.pet/servico?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+
+## License
+
+MIT — see `LICENSE`. Use it commercially, fork it, ship it.
+
+---
+
+### Em português
+
+O loop de teste para agentes: o construtor não assina o próprio trabalho. Um crítico roda checagens
+de verdade, dá nota 0–100 e barra a entrega abaixo do limite.
+
+```bash
+npx ai-test-loop --config loop.json   # não precisa de Python
+```
+
+Sem chave de API, sem dependência, sem chamada de modelo. Versão com entrega por e-mail e os packs
+prontos: https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop

ai_test_loop-1.1.0/ai_test_loop/__init__.py

@@ -0,0 +1,10 @@
+"""ai-test-loop — deterministic critic for AI agents.
+
+Este pacote é um casco fino em volta do mesmo `loop_runner.py` que o pacote npm usa (lá em
+versão Node). O contrato é idêntico: `SCORE=` / `GAPS=` / `EVIDENCE=` e exit code 0/1 para CI.
+
+Por que o casco existe: `pip install ai-test-loop` precisa dar o mesmo comando que
+`npx ai-test-loop`, senão o produto tem dois nomes e as estatísticas ficam partidas.
+"""
+
+__version__ = "1.1.0"

ai_test_loop-1.1.0/ai_test_loop/__main__.py

@@ -0,0 +1,55 @@
+"""Console entry point for `ai-test-loop`.
+
+Delega ao `loop_runner.py`, que continua sendo a implementação canônica em Python. Nada de
+lógica duplicada aqui: se o runner mudar, este arquivo não precisa mudar.
+"""
+
+import os
+import sys
+
+from . import __version__
+
+
+def _runner_path() -> str:
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "scripts", "loop_runner.py")
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+
+    # --version e --help do PRODUTO, não do argparse interno: quem digita
+    # `ai-test-loop --version` quer a versão do pacote.
+    if "--version" in argv or "-V" in argv:
+        print(__version__)
+        return 0
+    if not argv or "--help" in argv or "-h" in argv:
+        print(
+            f"ai-test-loop {__version__} — nota 0-100 no seu agente antes de entregar.\n"
+            "\n"
+            "USO\n"
+            "  ai-test-loop --config <arquivo.json>       roda as checagens e imprime a nota\n"
+            "  ai-test-loop --config <arq> --dry-run      mostra o que rodaria, sem executar\n"
+            "  ai-test-loop --config <arq> --quiet        só SCORE/GAPS/EVIDENCE\n"
+            "  ai-test-loop --config <arq> --json         relatório completo em JSON\n"
+            "  ai-test-loop --show-state                  última rodada e placar guardados\n"
+            "  ai-test-loop --version                     versão do pacote\n"
+            "\n"
+            "Pacote completo, packs e suporte: "
+            "https://skills.seu.pet/p/ai-test-loop"
+            "?utm_source=cli&utm_medium=help&utm_campaign=ai-test-loop\n"
+        )
+        return 0
+
+    runner = _runner_path()
+    if not os.path.exists(runner):
+        sys.stderr.write(f"ai-test-loop: runner não encontrado em {runner}\n")
+        return 2
+
+    # exec em vez de subprocess: o exit code do runner (0/1/2) é o exit code do comando,
+    # que é exatamente o que o CI consome.
+    os.execv(sys.executable, [sys.executable, runner, *argv])
+    return 2  # inalcançável
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ai_test_loop-1.1.0/ai_test_loop/scripts/loop_runner.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""loop_runner — the deterministic critic of the AI Test Loop.
+
+Runs a list of weighed checks for real, captures their raw output as evidence, and prints:
+
+    SCORE=<0-100>
+    GAPS=["<check>: <why it failed>", ...]
+    EVIDENCE=<path to the JSON report>
+
+The agent (builder) is not allowed to grade its own work; this script measures. It is
+deliberately dumb: exit codes + optional output patterns decide pass/fail. No model calls,
+no network, no telemetry.
+
+Config (JSON):
+
+{
+  "name": "my-project",
+  "threshold": 85,
+  "max_rounds": 8,
+  "checks": [
+    {"name": "unit tests",   "cmd": "pytest -q",           "weight": 40, "timeout_s": 900},
+    {"name": "build",        "cmd": "npm run build",       "weight": 25, "timeout_s": 600},
+    {"name": "lint",         "cmd": "ruff check .",        "weight": 10},
+    {"name": "no secrets",   "cmd": "gitleaks detect --no-banner", "weight": 15,
+     "fail_if_output_matches": "leaks found: [1-9]"},
+    {"name": "api responds", "cmd": "curl -sS localhost:8000/health", "weight": 10,
+     "must_match": "\"status\"\\s*:\\s*\"ok\""}
+  ]
+}
+
+Check keys:
+  cmd                      (required) shell command; runs with pipefail semantics via bash -o pipefail -c
+  weight                   (required) points; all weights are normalised, so they need not sum to 100
+  timeout_s                (optional, default 900) hard timeout — a timeout is a FAIL, never a skip
+  expect_exit              (optional, default 0) exit code that means pass
+  must_match               (optional) regex that MUST appear in combined output
+  fail_if_output_matches   (optional) regex that fails the check when it appears
+  required                 (optional, default true) when false, a FAIL scores 0 but is reported as a
+                           non-blocking gap (useful for "nice to have" checks)
+  cwd                      (optional) working directory for this check
+
+Usage:
+    python loop_runner.py --config loop.json [--round 2] [--json] [--quiet]
+    python loop_runner.py --config loop.json --show-state      # print round history and stop
+    python loop_runner.py --config loop.json --dry-run         # list checks, run nothing
+
+Exit code: 0 when SCORE >= threshold (gate passed), 1 when below, 2 on usage/config error.
+
+State: <config dir>/.<config-stem>-state.json accumulates every round, so a crash or a restart
+never loses the evidence trail. The report of the latest round is written to
+<config dir>/<config-stem>-report-r<round>.json. Names are derived from the config file so two
+projects in the same folder never share a history.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import re
+import shlex
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+
+DEFAULT_TIMEOUT = 900
+MAX_OUTPUT_CHARS = 8000
+
+
+def load_config(path: str) -> dict:
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            cfg = json.load(fh)
+    except FileNotFoundError:
+        sys.exit(f"[loop_runner] config not found: {path}")
+    except json.JSONDecodeError as exc:
+        sys.exit(f"[loop_runner] config is not valid JSON: {exc}")
+    checks = cfg.get("checks")
+    if not isinstance(checks, list) or not checks:
+        sys.exit("[loop_runner] config needs a non-empty 'checks' list")
+    for i, chk in enumerate(checks):
+        if not chk.get("cmd"):
+            sys.exit(f"[loop_runner] check #{i} has no 'cmd'")
+        if not isinstance(chk.get("weight", None), (int, float)) or chk["weight"] <= 0:
+            sys.exit(f"[loop_runner] check {chk.get('name', i)!r} needs a positive 'weight'")
+    cfg.setdefault("name", os.path.basename(os.path.dirname(os.path.abspath(path))) or "loop")
+    cfg.setdefault("threshold", 85)
+    cfg.setdefault("max_rounds", 8)
+    return cfg
+
+
+def run_check(chk: dict) -> dict:
+    """Run one check for real, return its result record with raw evidence."""
+    name = chk.get("name") or chk["cmd"][:40]
+    timeout = int(chk.get("timeout_s", DEFAULT_TIMEOUT))
+    cwd = chk.get("cwd") or None
+    expect_exit = int(chk.get("expect_exit", 0))
+    # bash -o pipefail: without it, `pytest | tail` returns tail's exit code (0) and a failing
+    # check scores as passing — the single most common false green in this kind of runner.
+    wrapped = ["bash", "-o", "pipefail", "-c", chk["cmd"]]
+    started = time.time()
+    timed_out = False
+    try:
+        proc = subprocess.run(
+            wrapped, cwd=cwd, capture_output=True, text=True, timeout=timeout,
+            stdin=subprocess.DEVNULL,
+        )
+        rc, out, err = proc.returncode, proc.stdout or "", proc.stderr or ""
+    except subprocess.TimeoutExpired as exc:
+        timed_out = True
+        rc = None
+        out = (exc.stdout or b"").decode("utf-8", "replace") if isinstance(exc.stdout, bytes) else (exc.stdout or "")
+        err = (exc.stderr or b"").decode("utf-8", "replace") if isinstance(exc.stderr, bytes) else (exc.stderr or "")
+    duration = round(time.time() - started, 2)
+    combined = (out or "") + ("\n" + err if err else "")
+
+    reasons: list[str] = []
+    if timed_out:
+        reasons.append(f"timed out after {timeout}s")
+    elif rc != expect_exit:
+        reasons.append(f"exit code {rc}, expected {expect_exit}")
+
+    must = chk.get("must_match")
+    if must and not re.search(must, combined):
+        reasons.append(f"output does not match required pattern /{must}/")
+
+    fail_pat = chk.get("fail_if_output_matches")
+    if fail_pat:
+        hit = re.search(fail_pat, combined)
+        if hit:
+            reasons.append(f"output matched failure pattern /{fail_pat}/: {hit.group(0)!r}")
+
+    passed = not reasons
+    evidence = combined.strip()
+    if len(evidence) > MAX_OUTPUT_CHARS:
+        evidence = evidence[: MAX_OUTPUT_CHARS // 2] + "\n...[truncated]...\n" + evidence[-MAX_OUTPUT_CHARS // 2:]
+    return {
+        "name": name,
+        "cmd": chk["cmd"],
+        "weight": float(chk["weight"]),
+        "required": bool(chk.get("required", True)),
+        "passed": passed,
+        "reasons": reasons,
+        "exit_code": rc,
+        "duration_s": duration,
+        "evidence": evidence,
+    }
+
+
+def score(checks: list[dict]) -> float:
+    total = sum(c["weight"] for c in checks) or 1.0
+    earned = sum(c["weight"] for c in checks if c["passed"])
+    return round(earned / total * 100, 1)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        add_help=True,
+        description="Deterministic critic for the AI Test Loop",
+        # 09/11/2026: o --help era o UNICO ponto de contato do dev com o pacote e
+        # nao dizia nada sobre o resto do produto. Medido: 555 downloads/npm no mes
+        # e ZERO hits com utm_source=npm na loja. O epilog e o unico lugar honesto
+        # de por o link (nao interrompe a saida, nao quebra script de terceiro).
+        epilog=("Full version, packs and paid support: "
+                "https://skills.seu.pet/p/ai-test-loop"
+                "?utm_source=cli&utm_medium=help&utm_campaign=ai-test-loop"),
+    )
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--round", type=int)
+    ap.add_argument("--json", action="store_true", help="also dump the full report as JSON to stdout")
+    ap.add_argument("--quiet", action="store_true", help="only SCORE/GAPS/EVIDENCE lines")
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--show-state", action="store_true")
+    args = ap.parse_args()
+
+    cfg_path = os.path.abspath(args.config)
+    cfg = load_config(cfg_path)
+    base = os.path.dirname(cfg_path)
+    # Per-config filenames: two configs in the same folder must not share one state file,
+    # otherwise rounds from project A pollute project B's history and round numbers.
+    stem = os.path.splitext(os.path.basename(cfg_path))[0]
+    state_path = os.path.join(base, f".{stem}-state.json")
+
+    if args.show_state:
+        if not os.path.exists(state_path):
+            print("[loop_runner] no state file yet")
+            return 0
+        with open(state_path, "r", encoding="utf-8") as fh:
+            st = json.load(fh)
+        for r in st.get("rounds", []):
+            print(f"round {r['round']}: SCORE={r['score']} threshold={r['threshold']} "
+                  f"failed={[c['name'] for c in r['checks'] if not c['passed']]}")
+        return 0
+
+    if args.dry_run:
+        for c in cfg["checks"]:
+            print(f"[dry-run] {c.get('name', c['cmd'][:40])}  weight={c['weight']}  cmd={c['cmd']}")
+        print(f"[dry-run] threshold={cfg['threshold']} max_rounds={cfg['max_rounds']}")
+        return 0
+
+    round_no = args.round
+    if round_no is None:
+        prev = 0
+        if os.path.exists(state_path):
+            with open(state_path, "r", encoding="utf-8") as fh:
+                prev = len(json.load(fh).get("rounds", []))
+        round_no = prev + 1
+
+    if round_no > int(cfg["max_rounds"]):
+        print(f"ROUND: {round_no}  ABORT: exceeded max_rounds={cfg['max_rounds']}")
+        print("GAPS=[\"round budget exhausted — the check set or the threshold needs revisiting\"]")
+        return 1
+
+    results = []
+    for chk in cfg["checks"]:
+        if not args.quiet:
+            print(f"[loop_runner] round {round_no}: running {chk.get('name', chk['cmd'][:40])!r} ...",
+                  file=sys.stderr, flush=True)
+        results.append(run_check(chk))
+
+    value = score(results)
+    threshold = float(cfg["threshold"])
+    gate = value >= threshold
+    gaps = [f"{c['name']}: {'; '.join(c['reasons'])}" for c in results if not c["passed"] and c["required"]]
+    soft = [f"{c['name']}: {'; '.join(c['reasons'])}" for c in results if not c["passed"] and not c["required"]]
+
+    report = {
+        "project": cfg["name"],
+        "round": round_no,
+        "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "threshold": threshold,
+        "score": value,
+        "gate": "passed" if gate else "failed",
+        "checks": results,
+        "gaps": gaps,
+        "non_blocking_gaps": soft,
+    }
+    report_path = os.path.join(base, f"{stem}-report-r{round_no}.json")
+    pathlib.Path(report_path).write_text(
+        json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    state = {"project": cfg["name"], "rounds": []}
+    if os.path.exists(state_path):
+        try:
+            with open(state_path, "r", encoding="utf-8") as fh:
+                state = json.load(fh)
+            state.setdefault("rounds", [])
+        except json.JSONDecodeError:
+            pass
+    state["rounds"].append({"round": round_no, "score": value, "threshold": threshold,
+                            "gate": report["gate"], "ts": report["ts"], "report": report_path,
+                            "checks": results})
+    pathlib.Path(state_path).write_text(
+        json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    if not args.quiet:
+        for c in results:
+            status = "PASS" if c["passed"] else "FAIL"
+            detail = c["evidence"].strip().splitlines()[-1][:160] if c["evidence"].strip() else "(no output)"
+            print(f"  {status}  {c['name']:<28} w={c['weight']:<5} {c['duration_s']:>7}s  {detail}")
+
+    print(f"SCORE={value}")
+    print(f"THRESHOLD={threshold}")
+    print(f"GATE={'passed' if gate else 'failed'} (round {round_no}/{cfg['max_rounds']})")
+    print(f"GAPS={json.dumps(gaps, ensure_ascii=False)}")
+    if soft:
+        print(f"NON_BLOCKING_GAPS={json.dumps(soft, ensure_ascii=False)}")
+    print(f"EVIDENCE={report_path}")
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 0 if gate else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ai_test_loop-1.1.0/ai_test_loop.egg-info/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: ai-test-loop
+Version: 1.1.0
+Summary: Deterministic critic for AI agents: runs weighed checks for real, scores 0-100 and blocks delivery below the threshold.
+Author: Samuel Medeiros
+License: MIT
+Project-URL: Homepage, https://skills.seu.pet/en/p/ai-test-loop?utm_source=pypi&utm_medium=readme&utm_campaign=ai-test-loop
+Project-URL: Repository, https://github.com/Samuelfmedeiros/ai-test-loop
+Project-URL: Changelog, https://github.com/Samuelfmedeiros/ai-test-loop/releases
+Keywords: mcp,ai-agent,ai-agents,llm,testing,test-loop,quality-gate,delivery-gate,critic,claude-code,cursor,code-review
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ai-test-loop
+
+**Your agent grades its own homework.** This makes that impossible: a critic script runs real checks,
+scores the artifact 0–100, and a fail-closed gate blocks delivery below the threshold.
+
+```bash
+npx ai-test-loop --config loop.json     # zero install, no Python needed
+```
+
+Real output, not a mockup:
+
+```
+  PASS  unit tests                   w=40     12.4s  41 passed in 12.31s
+  FAIL  build                        w=20      3.1s  error TS2307: Cannot find module './api'
+  PASS  no secrets                   w=15      0.8s  no leaks found
+SCORE=75.0
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+```
+
+> **Want this wired into your repo, with the visual-diff gate and the delivery report?**
+> The ready-made packs are at **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+> — or grab the free runner first and see if the loop earns its place.
+
+No API keys, no dependencies, no model calls. The runner is deliberately dumb: exit codes and
+optional output patterns decide pass/fail. The model never gets to *say* the work is good — it has
+to *show* it.
+
+---
+
+## Install
+
+Same package name everywhere. Both registries, same name:
+
+```bash
+npx ai-test-loop --help          # Node 18+ — nothing to install
+pip install ai-test-loop         # Python 3.9+ — same engine (PyPI)
+```
+
+`npx` is the fastest path: it downloads and runs in about five seconds, no virtualenv, no Python.
+The npm package carries a Node port of the runner; the PyPI package carries the Python one. Both
+print the same `SCORE=` / `GAPS=` / `EVIDENCE=` contract, so the gate you run locally is the gate CI
+runs.
+
+Verify with a dry run — it lists the checks and weights without executing anything:
+
+```bash
+npx ai-test-loop --config templates/loop.example.json --dry-run
+```
+
+> Older docs and articles mention `pip install agent-test-loop`. That is the previous PyPI name and
+> still works — it is the same engine, kept as a mirror so existing installs do not break. New code
+> should use `ai-test-loop`.
+
+## The problem
+
+Ask an agent "is this done?" and it answers about its own reasoning. The same context that produced
+the artifact also decides it is correct, so real defects survive to delivery:
+
+- a handler that is never called (tests pass, feature dead)
+- a test that passes because it asserts nothing
+- a page that breaks only at mobile width
+- a migration that works on the author's data and nowhere else
+- a "fix" that reverted a config someone changed on purpose
+
+Running "one more review pass" does not help, because the reviewer and the builder are the same
+process. Separating them is the whole trick.
+
+## Quickstart
+
+```bash
+npx ai-test-loop --config loop.json
+```
+
+Describe your checks once — name, command, weight:
+
+```json
+{
+  "name": "my-project",
+  "threshold": 85,
+  "max_rounds": 8,
+  "checks": [
+    {"name": "unit tests", "cmd": "pytest -q", "weight": 35, "timeout_s": 900},
+    {"name": "type check", "cmd": "mypy src", "weight": 10},
+    {"name": "build",      "cmd": "npm run build", "weight": 20},
+    {"name": "api up",     "cmd": "curl -sS 127.0.0.1:8000/health", "weight": 15,
+     "must_match": "\"status\"\\s*:\\s*\"ok\""},
+    {"name": "no secrets", "cmd": "gitleaks detect --no-banner", "weight": 20,
+     "fail_if_output_matches": "leaks found: [1-9]", "required": true}
+  ]
+}
+```
+
+Output is machine-readable, so the *agent* can act on it and a CI job can gate on it:
+
+```
+SCORE=75.0
+THRESHOLD=85
+GATE=failed (round 1/8)
+GAPS=["build: exit code 2, expected 0"]
+EVIDENCE=loop-report-r1.json
+```
+
+Exit code is `0` when the gate passes and `1` when it fails — so `npx ai-test-loop --config
+loop.json` is a valid CI step on its own, with no parsing.
+
+Fix the **single largest** gap, run `--round 2`, repeat. Cap the rounds (8 is plenty): if the score
+never converges, the check set is wrong, not the code.
+
+## Config reference
+
+| Key | Meaning |
+|---|---|
+| `cmd` | (required) shell command, run with `bash -o pipefail -c` |
+| `weight` | (required) points; weights are normalised, they need not sum to 100 |
+| `timeout_s` | default 900 — a timeout is a **FAIL**, never a skip |
+| `expect_exit` | default 0 |
+| `must_match` | regex that must appear in the combined stdout+stderr |
+| `fail_if_output_matches` | regex that fails the check when it appears |
+| `required` | default `true`; `false` scores 0 but reports as a non-blocking gap |
+| `cwd` | working directory for that check |
+
+`bash -o pipefail` is not decoration: without it `pytest | tail` returns tail's exit code (0), so a
+failing suite scores as passing. That is the most common false green in runners like this one.
+
+## The four roles (never merge them)
+
+| Role | Who | Job |
+|---|---|---|
+| Orchestrator | the agent running the task | picks checks, runs rounds, owns the report |
+| Builder | the agent/model that wrote the artifact | fixes one class of gap per pass |
+| Critic | this script + your checks | runs real commands, returns score + gaps |
+| Reviewer | a **separate** context/model | audits critic and builder, can reopen the loop |
+
+Rule zero: builder ≠ critic ≠ reviewer. If one context does all three, the loop is theatre.
+
+## Three rules that make it honest
+
+1. **Every point is earned by a command that actually ran.** No points for "read the code". The
+   report stores the raw output next to each score.
+2. **`NOT VERIFIABLE` is not a pass.** If a check cannot run (missing device, no network, jail), it
+   scores 0 and the report says why. Silent skips are how a green board lies.
+3. **The security gate is fail-closed.** A secret in the diff or history, a high-severity SAST
+   finding, or an auth/path-traversal/injection issue found in review blocks delivery **even with a
+   perfect score**. An inconclusive answer counts as blocked, never as pass.
+
+## Reviewer panel
+
+For anything other people will use, ask 2–3 specialists instead of one generalist — quality and
+security always, performance only if there is a build or runtime cost, UX only if there is a
+user-facing surface. Each returns strict JSON:
+
+```json
+{"parecer":"CONCORDO|DISCORDO","nota":0-100,"gaps":["..."],"texto":"one paragraph with evidence"}
+```
+
+Consensus → deliver. Majority disagree → reopen the loop with the combined gaps. Prompt in
+`references/reviewer-prompt.md`, starting rubric in `references/scoring-rubric.md`.
+
+## Telemetry (opt-out, and what it is not)
+
+The `npx ai-test-loop` wrapper sends **one anonymous event per run** so the project knows whether
+the tool is actually used — downloads alone are not usage (npm counts mirrors and CI).
+
+What is sent: event type (`run`/`help`/`version`/`erro`), package version, Node major, OS name,
+duration in ms, and — only on a real run — the final score and the number of gaps.
+
+What is **never** sent: your IP (not logged server-side), e-mail, project path, file names, the
+content of your checks, the command output, or anything from your code.
+
+The install id is a random UUID written to `~/.ai-test-loop/telemetry-id` once. It counts machines,
+not people. Delete that file and you are a new machine.
+
+```bash
+ai-test-loop --no-telemetry ...          # that run only
+export AI_TEST_LOOP_NO_TELEMETRY=1       # permanently, in your shell profile
+export DO_NOT_TRACK=1                    # the ecosystem-wide convention, also respected
+# CI=1 is detected automatically: pipelines are not people
+```
+
+Telemetry never blocks and never waits: if the network is down the CLI runs exactly the same.
+
+## When not to use it
+
+Throwaway exploration, spike branches, and one-line answers where the cost of the loop exceeds the
+cost of being wrong. It is for artifacts a human will rely on.
+
+## Files
+
+| Path | What |
+|---|---|
+| `bin/cli.js` | the `npx` entry point (wrapper + telemetry) |
+| `scripts/loop_runner.js` | the deterministic critic, Node port — zero dependencies |
+| `scripts/loop_runner.py` | the same critic in Python (used by the pip package) |
+| `scripts/selftest.js` | 22 assertions covering every way a check can fail — `npm test` |
+| `SKILL.md` | the loop, the scoring rules, the fail-closed gate — drop it in your agent's skills dir |
+| `references/reviewer-prompt.md` | independent-review prompt, strict JSON output |
+| `references/scoring-rubric.md` | starting weights |
+| `templates/loop.example.json` | config with the usual check set |
+
+`npm test` runs the selftest. It needs nothing but node.
+
+## Get the full pack
+
+This repo is the free, complete tool. The store has the ready-made packs for the cases where
+writing the checks is the slow part — CI gates, visual regression, MCP servers, MLOps guards:
+
+- Free download / e-mail delivery: **https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Full pack: **https://skills.seu.pet/en/p/pack-completo?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Catalog: **https://skills.seu.pet/?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+- Want it installed and wired into your repo: **https://skills.seu.pet/servico?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop**
+
+## License
+
+MIT — see `LICENSE`. Use it commercially, fork it, ship it.
+
+---
+
+### Em português
+
+O loop de teste para agentes: o construtor não assina o próprio trabalho. Um crítico roda checagens
+de verdade, dá nota 0–100 e barra a entrega abaixo do limite.
+
+```bash
+npx ai-test-loop --config loop.json   # não precisa de Python
+```
+
+Sem chave de API, sem dependência, sem chamada de modelo. Versão com entrega por e-mail e os packs
+prontos: https://skills.seu.pet/gratis/ai-test-loop?utm_source=npm&utm_medium=readme&utm_campaign=ai-test-loop

ai_test_loop-1.1.0/ai_test_loop.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+ai_test_loop/__init__.py
+ai_test_loop/__main__.py
+ai_test_loop.egg-info/PKG-INFO
+ai_test_loop.egg-info/SOURCES.txt
+ai_test_loop.egg-info/dependency_links.txt
+ai_test_loop.egg-info/entry_points.txt
+ai_test_loop.egg-info/top_level.txt
+ai_test_loop/scripts/loop_runner.py
+tests/test_cli.py

ai_test_loop-1.1.0/ai_test_loop.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ai_test_loop-1.1.0/ai_test_loop.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai-test-loop = ai_test_loop.__main__:main

ai_test_loop-1.1.0/ai_test_loop.egg-info/top_level.txt

@@ -0,0 +1 @@
+ai_test_loop

ai_test_loop-1.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai-test-loop"
+version = "1.1.0"
+description = "Deterministic critic for AI agents: runs weighed checks for real, scores 0-100 and blocks delivery below the threshold."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Samuel Medeiros" }]
+keywords = [
+    "mcp", "ai-agent", "ai-agents", "llm", "testing", "test-loop",
+    "quality-gate", "delivery-gate", "critic", "claude-code", "cursor", "code-review",
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://skills.seu.pet/en/p/ai-test-loop?utm_source=pypi&utm_medium=readme&utm_campaign=ai-test-loop"
+Repository = "https://github.com/Samuelfmedeiros/ai-test-loop"
+Changelog = "https://github.com/Samuelfmedeiros/ai-test-loop/releases"
+
+[project.scripts]
+ai-test-loop = "ai_test_loop.__main__:main"
+
+[tool.setuptools]
+packages = ["ai_test_loop"]
+
+[tool.setuptools.package-data]
+ai_test_loop = ["scripts/*.py"]

ai_test_loop-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai_test_loop-1.1.0/tests/test_cli.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Testes do CLI do ai-test-loop — o que o usuario ve ao rodar `npx ai-test-loop`.
+
+Por que existe: a 1.0.2 ficou semanas publicada com `--version` quebrado e sem
+argumento cuspindo erro cru do argparse, porque o pacote nao tinha NENHUM teste.
+555 downloads no mes e nenhum sinal de que o comando documentado funcionava.
+
+Nao usa pytest: o pacote e stdlib-only por design, e estes testes rodam com
+`python3 tests/test_cli.py` em qualquer maquina com node.
+"""
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CLI = os.path.join(RAIZ, "bin", "cli.js")
+
+
+def roda(*args, env_extra=None, espera_erro=False):
+    """Executa o CLI e devolve (rc, stdout, stderr)."""
+    env = dict(os.environ)
+    # telemetria desligada: teste nao deve escrever no servidor do site
+    env["AI_TEST_LOOP_NO_TELEMETRY"] = "1"
+    if env_extra:
+        env.update(env_extra)
+    p = subprocess.run(
+        ["node", CLI, *args],
+        capture_output=True, text=True, timeout=120, env=env,
+    )
+    return p.returncode, p.stdout, p.stderr
+
+
+class TestAjuda(unittest.TestCase):
+    def test_help_mostra_a_ajuda_do_produto(self):
+        """`--help` tem de explicar o que a ferramenta faz, nao o usage do Python."""
+        rc, out, _ = roda("--help")
+        self.assertEqual(rc, 0)
+        self.assertIn("ai-test-loop", out)
+        self.assertIn("USO", out)
+        self.assertIn("--config", out)
+        self.assertIn("PRIMEIRA VEZ", out)
+        # o usage do argparse do runner nao deve vazar
+        self.assertNotIn("loop_runner.py [-h]", out)
+        self.assertNotIn("show this help message and exit", out)
+
+    def test_help_leva_para_a_loja(self):
+        """O help e o degrau mais barato do funil: tem de ter o link."""
+        _, out, _ = roda("--help")
+        self.assertIn("skills.seu.pet/p/ai-test-loop", out)
+        self.assertIn("utm_source=cli", out)
+
+    def test_sem_argumento_mostra_ajuda_em_vez_de_erro(self):
+        """Sem argumento o usuario via 'error: --config is required' e ia embora."""
+        rc, out, err = roda()
+        self.assertEqual(rc, 0, f"sem argumento deveria sair limpo, veio rc={rc}")
+        self.assertIn("USO", out)
+        self.assertNotIn("the following arguments are required", out + err)
+        self.assertNotIn("usage: loop_runner.py", out + err)
+
+
+class TestVersao(unittest.TestCase):
+    def test_version_responde_a_versao_do_pacote(self):
+        rc, out, err = roda("--version")
+        self.assertEqual(rc, 0)
+        with open(os.path.join(RAIZ, "package.json"), encoding="utf-8") as f:
+            versao = json.load(f)["version"]
+        self.assertEqual(out.strip(), versao, "a saida tem de ser SO a versao")
+        # o Python nao pode rodar depois e imprimir o usage dele
+        self.assertNotIn("loop_runner.py", out + err)
+        self.assertNotIn("--config", out + err)
+
+
+class TestRunReal(unittest.TestCase):
+    def test_dry_run_lista_os_checks(self):
+        rc, out, _ = roda("--config", os.path.join(RAIZ, "templates", "loop.example.json"),
+                          "--dry-run")
+        self.assertEqual(rc, 0)
+        self.assertIn("[dry-run]", out)
+        self.assertIn("threshold=", out)
+
+    def test_run_de_verdade_da_nota_e_gaps(self):
+        """Um run real tem de produzir SCORE, GATE e GAPS — nao so ecoar."""
+        with tempfile.TemporaryDirectory() as d:
+            cfg = os.path.join(d, "mini.json")
+            with open(cfg, "w", encoding="utf-8") as f:
+                json.dump({
+                    "threshold": 50, "max_rounds": 1,
+                    "checks": [
+                        {"name": "passa", "cmd": "true", "weight": 50, "pass_when": "exit0"},
+                        {"name": "falha", "cmd": "false", "weight": 50, "pass_when": "exit0"},
+                    ],
+                }, f)
+            rc, out, _ = roda("--config", cfg)
+            self.assertIn("SCORE=", out)
+            self.assertIn("GATE=", out)
+            self.assertIn("GAPS=", out)
+            # 50 de 100: um passa, um falha, e o gap nomeia qual
+            self.assertIn("SCORE=50", out)
+            self.assertIn("falha", out.split("GAPS=")[1])
+
+
+class TestPythonAusente(unittest.TestCase):
+    def test_python_inexistente_da_erro_claro(self):
+        """Sem python o usuario precisa saber o que instalar, nao ver stack trace."""
+        rc, out, err = roda("--config", "x.json",
+                            env_extra={"AI_TEST_LOOP_PYTHON": "/caminho/que/nao/existe"})
+        self.assertNotEqual(rc, 0)
+        juntos = out + err
+        self.assertIn("Python 3", juntos)
+        self.assertIn("AI_TEST_LOOP_PYTHON", juntos)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)