forgeqe-cli 2.1.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

forgeqe_cli/__init__.py

@@ -4,4 +4,4 @@ The agent itself is the npm package ``@capagents/forgeqe`` (OpenTUI + Bun).
 This distribution only puts a ``forgeqe`` command on PATH.
 """
 
-__version__ = "2.1.1"
+__version__ = "2.2.2"

forgeqe_cli/pytest_plugin.py

@@ -0,0 +1,132 @@
+"""ForgeQE plugin for pytest: an HTML report after every run, from the terminal, an IDE's test runner, or CI.
+
+pytest loads it by itself from the forgeqe-cli wheel (the pytest11 entry point). It is on in a folder with
+forgeqe.yaml or .forgeqe/, or with ``pytest --forgeqe-report`` or FORGEQE_REPORT=1; FORGEQE_REPORT=0 turns it off.
+At the end of the run it writes the results, with each failure's message and traceback, to
+.pytest_cache/forgeqe/results.json and runs ``forgeqe report`` on it.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+
+
+def _clean(text: str) -> str:
+    return ANSI.sub("", text or "")
+
+
+def pytest_addoption(parser):
+    parser.getgroup("forgeqe").addoption(
+        "--forgeqe-report", action="store_true", default=False, help="write a ForgeQE HTML report after the run"
+    )
+
+
+def _active(config) -> bool:
+    flag = os.environ.get("FORGEQE_REPORT")
+    if flag == "0":
+        return False
+    if flag == "1" or config.getoption("forgeqe_report", False):
+        return True
+    root = Path(str(config.rootpath))
+    return (root / "forgeqe.yaml").exists() or (root / ".forgeqe").is_dir()
+
+
+def pytest_configure(config):
+    # An xdist worker sends its results to the controller, which writes the one report.
+    if hasattr(config, "workerinput") or not _active(config):
+        return
+    config.pluginmanager.register(_Collector(config), "forgeqe-collector")
+
+
+def _message(report) -> str:
+    crash = getattr(getattr(report, "longrepr", None), "reprcrash", None)
+    text = crash.message if crash is not None else str(getattr(report, "longrepr", "") or "")
+    first = next((line.strip() for line in _clean(text).splitlines() if line.strip()), "")
+    return first[:300]
+
+
+class _Collector:
+    def __init__(self, config):
+        self.config = config
+        self.tests: dict[str, dict] = {}
+        self.started = datetime.now(timezone.utc)
+        self.t0 = time.monotonic()
+        self.line = ""
+
+    def pytest_runtest_logreport(self, report):
+        nodeid = report.nodeid
+        test = self.tests.setdefault(
+            nodeid, {"name": " › ".join(nodeid.split("::")), "status": "passed", "seconds": 0.0, "file": report.location[0]}
+        )
+        if report.outcome == "rerun":
+            # pytest-rerunfailures: a failure that is run again; passing later makes the test flaky, not failed.
+            test["rerun"] = True
+            test.setdefault("message", _message(report))
+            test.setdefault("details", _clean(report.longreprtext))
+            return
+        test["seconds"] = round(test["seconds"] + (report.duration or 0), 3)
+        if report.failed:
+            if test["status"] != "failed":
+                test["message"] = _message(report)
+                test["details"] = _clean(report.longreprtext)
+            test["status"] = "failed"
+        elif report.skipped and test["status"] == "passed" and report.when in ("setup", "call"):
+            test["status"] = "skipped"
+
+    def pytest_sessionfinish(self, session):
+        if not self.tests:
+            return
+        tests = []
+        for test in self.tests.values():
+            rerun = test.pop("rerun", False)
+            if test["status"] == "passed" and rerun:
+                test["flaky"] = True
+            elif test["status"] != "failed" and not test.get("flaky"):
+                test.pop("message", None)
+                test.pop("details", None)
+            tests.append({k: v for k, v in test.items() if v not in ("", None)})
+        doc = {
+            "format": "forgeqe-results",
+            "version": 1,
+            "framework": "pytest",
+            "startedAt": self.started.isoformat(),
+            "ms": round((time.monotonic() - self.t0) * 1000),
+            "command": " ".join(["pytest", *self.config.invocation_params.args])[:500],
+            "tests": tests,
+        }
+        cache = getattr(self.config, "cache", None)
+        folder = Path(cache.mkdir("forgeqe")) if cache is not None else Path(tempfile.mkdtemp(prefix="forgeqe-"))
+        path = folder / "results.json"
+        path.write_text(json.dumps(doc, indent=2) + "\n", encoding="utf-8")
+        self.line = _report(path, Path(str(self.config.rootpath)))
+
+    def pytest_terminal_summary(self, terminalreporter):
+        if self.line:
+            terminalreporter.write_line(self.line)
+
+
+def _report(path: Path, root: Path) -> str:
+    """Run forgeqe report on the results; the line to show."""
+    # This wheel's own launcher, by the Python running pytest: no PATH lookup and no .cmd shim on Windows.
+    bin_ = os.environ.get("FORGEQE_BIN")
+    cmd = [bin_, "report", str(path)] if bin_ else [sys.executable, "-m", "forgeqe_cli", "report", str(path)]
+    try:
+        run = subprocess.run(cmd, cwd=str(root), capture_output=True, text=True, timeout=300)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return f"ForgeQE: no report ({exc.__class__.__name__}). Build it with: forgeqe report {path}"
+    # forgeqe report exits 1 when a test failed: that is a report, not an error.
+    line = next((l for l in _clean(run.stdout).splitlines() if l.startswith("Report")), "") if run.returncode <= 1 else ""
+    if line:
+        return "ForgeQE report: " + line[len("Report"):].strip()
+    why = (_clean(run.stderr).strip().splitlines() or ["it did not finish"])[-1]
+    return f"ForgeQE: no report ({why}). Build it with: forgeqe report {path}"

{forgeqe_cli-2.1.1.dist-info → forgeqe_cli-2.2.2.dist-info}/METADATA

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: forgeqe-cli
-Version: 2.1.1
+Version: 2.2.2
 Summary: pip launcher for the ForgeQE browser agent (npm package: @capagents/forgeqe)
 Author: CLI-Agents
 License: MIT
 Keywords: forgeqe,browser,agent,cli,opentui
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
 
 # ForgeQE
 
@@ -132,7 +134,7 @@ ForgeQE's agent needs the agent runtime (downloaded automatically, see Install)
 
 Every live run records each page it visits in `.forgeqe/memory` next to `forgeqe.yaml` (`~/.forgeqe/memory` when there is no config file): every interactive element, with all of its locators (test id, id, role and name, label, placeholder, alt, title, href, text, CSS, XPath), a confidence % for each, and when it was first seen, last seen, and last used. Confidence rises when a locator keeps matching exactly one element and works when used, and falls when it goes missing or fails.
 
-A goal that passed before is replayed from memory with no model calls. Each step finds its element by the highest-confidence locator that still matches, so a renamed button or a changed id heals itself. The agent then checks the result with one model call (`replay: verify`), or the run finishes without the model (`replay: trust`). If a step cannot be found, the agent takes over from that point. Generated specs use the best locator from memory.
+A goal that passed before is replayed from memory with no model calls. Each step finds its element by the highest-confidence locator that still matches, so a renamed button or a changed id heals itself. The agent then checks the result with one model call (`replay: verify`), or the run finishes without the model (`replay: trust`). If a step cannot be found, the agent takes over from that point. A run that failed because an expected result did not hold keeps the steps up to that check, so the next run of the case replays them and the agent checks the result again there, instead of exploring the whole case again. On every page memory knows, the agent is told which controls earlier runs used, with the index each has on the page right now, so it acts on them in one step. Generated specs use the best locator from memory.
 
 ```bash
 forgeqe memory                          # hosts, pages, elements, flows
@@ -140,9 +142,12 @@ forgeqe memory show booking.com         # a host's pages
 forgeqe memory show https://app.test/login --locators   # every locator with confidence
 forgeqe memory flows --steps            # recorded goals and their steps
 forgeqe memory clear booking.com --yes
+forgeqe memory stats                    # how often memory stood in for the model, per area
 forgeqe run "..." --replay trust       # or --replay off, --no-memory
 ```
 
+A new goal on a site ForgeQE knows replays the start it shares with an earlier goal there: a sign-in with a saved login, a cookie banner, and the steps whose controls or values the new goal names. Mobile and desktop explores do the same from app memory. A goal that passed before replays with no model call when its checks still hold, a failed explore is picked up where it went wrong, and a control a heal found once is used again without the model. Saved API calls replay inside a browser flow when the server answers as before, and API scenarios planned from the same test cases or text are reused. A rerun of any of these runs as recorded, without ForgeQE's agent.
+
 ## Skills
 
 Skills teach the agents what a prompt can't know: your repo's test conventions, a framework, or how to drive an app. A skill is a folder with a `SKILL.md` (the Agent Skills format: `name`, `description`, then instructions), plus ForgeQE's `agents: [forgeqe, scribe, browser]` to say who uses it. ForgeQE ships `playwright-typescript`, `dotnet-nunit-playwright` and `testcontainers` for Scribe, `dynamics-365` for the browser agent, and `writing-skills` for ForgeQE's agent. Your own go in `.forgeqe/skills` next to `forgeqe.yaml` (commit them) or `~/.forgeqe/skills`; a project skill replaces a built-in one with the same name. Skills in `~/.claude/skills` and `~/.agents/skills` are used only with `skills.external: true`.

forgeqe_cli-2.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+forgeqe_cli/__init__.py,sha256=P8v4jSY_ROSVD98F0zQcv49wFe88He6hTop3NqlqJrg,200
+forgeqe_cli/__main__.py,sha256=frkRQzq1Cd7HI3aiw0W0eJ-w1r8VkXOJrv0wIR-on9Y,46
+forgeqe_cli/launcher.py,sha256=GKmbo1W4xpNz2I3smM0CXGbnAYRdwhrX8Pe48Gr4kgs,6413
+forgeqe_cli/pytest_plugin.py,sha256=f_hH2JXv059oJwHBBdR-TZAhuFYqM2LMr6vAAcRpC5o,5570
+forgeqe_cli-2.2.2.dist-info/licenses/LICENSE,sha256=Z_3_KODt79ZZl4nLelIVBSsVsL6AhEypl7HouMkKjYA,3079
+forgeqe_cli-2.2.2.dist-info/METADATA,sha256=LB2sIwF4wFAVpWvZgpbo42iftHYyk4fXcQDbnDBkQ84,50190
+forgeqe_cli-2.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+forgeqe_cli-2.2.2.dist-info/entry_points.txt,sha256=KphefM5TY2MOIbABNg2UJJQsEZUZgrNM4ZD3lrIphVg,139
+forgeqe_cli-2.2.2.dist-info/top_level.txt,sha256=YrCSJdE_QY2GlHw_tgRYsQpZ1cSiIejC9swAUcRLpD8,12
+forgeqe_cli-2.2.2.dist-info/RECORD,,

{forgeqe_cli-2.1.1.dist-info → forgeqe_cli-2.2.2.dist-info}/entry_points.txt

@@ -1,3 +1,6 @@
 [console_scripts]
 forgeqe = forgeqe_cli.launcher:main
 webpilot = forgeqe_cli.launcher:main
+
+[pytest11]
+forgeqe = forgeqe_cli.pytest_plugin

forgeqe_cli-2.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+ForgeQE Software Licence
+
+Copyright (c) 2026 Javed Khan. All rights reserved.
+
+ForgeQE, its documentation, prompts, skills, and accompanying files (together, "the Software") are proprietary and confidential. The Software is licensed, not sold.
+
+1. Grant. Subject to a written agreement with the licensor, the licensee may install and use the Software on its own systems, for its own internal business purposes, for the term and in the quantities that agreement states. No other right is granted.
+
+2. Restrictions. Except to the extent that applicable law expressly permits it despite this restriction, the licensee shall not, and shall not allow anyone else to:
+   (a) copy the Software, other than one copy for backup;
+   (b) modify, translate, adapt, or create derivative works of the Software;
+   (c) reverse engineer, decompile, disassemble, deobfuscate, or otherwise attempt to derive the source code, prompts, algorithms, structure, or operation of the Software;
+   (d) sell, rent, lease, lend, sublicense, distribute, publish, host for others, or otherwise make the Software available to any third party;
+   (e) remove, hide, or alter any proprietary notice in the Software;
+   (f) use the Software, or knowledge of its operation, to build a product or service that competes with it.
+
+3. Third-party software. The Software contains and installs open source components, listed with their licences in THIRD_PARTY_NOTICES.md. Each such component is governed by its own licence, and nothing in this licence restricts a right that licence grants.
+
+4. Ownership. The licensor and its licensors own all right, title, and interest in the Software, including all intellectual property rights. The licensee's feedback may be used by the licensor without restriction.
+
+5. Confidentiality. The Software, including its prompts and documentation, is confidential information of the licensor. The licensee shall protect it with at least the care it uses for its own confidential information, and shall disclose it only to those of its staff who need it to use the Software under this licence.
+
+6. No warranty. The Software is provided "as is", without warranty of any kind, express or implied, including the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, except where a written agreement with the licensor says otherwise.
+
+7. Limitation of liability. To the maximum extent permitted by law, the licensor shall not be liable for any indirect, incidental, special, consequential, or punitive damages, or for loss of profits, data, or business, arising out of or related to the Software, and its total liability shall not exceed the fees the licensee paid for the Software in the twelve months before the claim.
+
+8. Termination. This licence ends automatically if the licensee breaches it. On termination, the licensee shall stop using the Software and destroy every copy. Sections 2 to 7 survive termination.
+
+9. Governing law. The written agreement between the licensor and the licensee states the governing law and the forum for disputes.

forgeqe_cli-2.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-forgeqe_cli/__init__.py,sha256=Px_1pNrFTrZYc8pozzZ2dPZt2jKxs76rdbY3RdnxpCQ,200
-forgeqe_cli/__main__.py,sha256=frkRQzq1Cd7HI3aiw0W0eJ-w1r8VkXOJrv0wIR-on9Y,46
-forgeqe_cli/launcher.py,sha256=GKmbo1W4xpNz2I3smM0CXGbnAYRdwhrX8Pe48Gr4kgs,6413
-forgeqe_cli-2.1.1.dist-info/METADATA,sha256=kBFmJ9HbTPlTJAMpTINK9lPGCNs-_7Ah35Xx5kE1pp8,49004
-forgeqe_cli-2.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-forgeqe_cli-2.1.1.dist-info/entry_points.txt,sha256=1IHZSsCnhKZfoCBsdScd7pRKwRzQ5bruc1Nk_FA5SI4,91
-forgeqe_cli-2.1.1.dist-info/top_level.txt,sha256=YrCSJdE_QY2GlHw_tgRYsQpZ1cSiIejC9swAUcRLpD8,12
-forgeqe_cli-2.1.1.dist-info/RECORD,,