norn-cli 0.8.2__tar.gz → 0.8.3__tar.gz

{norn_cli-0.8.2/src/norn_cli.egg-info → norn_cli-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: norn-cli
-Version: 0.8.2
+Version: 0.8.3
 Summary: Norn: a provider-neutral multi-agent development harness
 License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/uruca-kk/norn
@@ -139,6 +139,43 @@ removed when testing ends.
 For distributable projects, prefer a reviewed, repository-owned E2E command over
 granting a model browser or host permissions:
 
+```bash
+# Adapt the one detected Playwright/Cypress suite. This is a dry run.
+norn init-e2e --adapter existing --project /path/to/repository
+
+# Or scaffold a new Playwright entrypoint in a selected workspace package.
+norn init-e2e --preset playwright --package packages/web --project /path/to/repository
+```
+
+`init-e2e` detects npm, pnpm, yarn, or bun and common E2E scripts/configs. It prints
+the files, minimal Norn YAML, evidence limits, and an optional `git.worktree_setup`
+copy step without changing the repository. Add `--write` after review. Use
+`--external-server` for an already-running Docker/external server, or
+`--server-script NAME` when the project script is not `dev`, `start`, or `serve`.
+`--base-url` must be a loopback HTTP(S) URL.
+
+The existing-suite adapter generates a repository-owned runner and, for Playwright,
+a small config that extends the existing config while disabling its `webServer` so
+Norn remains the only server owner. The Playwright preset additionally creates a
+bounded evidence helper, a smoke spec, a JSON reporter, and low-volume artifact
+defaults. It does not install Playwright unless `--install-dependency` is explicitly
+combined with `--write`; existing framework versions and fixtures remain owned by
+the project.
+
+Re-running `--write` is idempotent. Existing generated files, package scripts, or
+Norn config values are not replaced when they differ; `--force` is the explicit
+migration path. Validate the checked-in contract without launching a browser:
+
+```bash
+norn init-e2e --adapter existing --external-server --check --project /path/to/repository
+norn init-e2e --preset playwright --package packages/web --check --project /path/to/repository
+```
+
+The generated runner receives `NORN_E2E_BASE_URL` and
+`NORN_E2E_EVIDENCE_DIR`, writes its own result record, and keeps evidence within
+the 20-file / 64 MiB limit. Its corresponding configuration is a shell-free argv
+list:
+
 ```yaml
 e2e:
   require_all_testers: false
@@ -153,13 +190,21 @@ Norn runs the four static tester roles in parallel, starts or checks the one sha
 server, then executes `runner.command` exactly once as a shell-free argv list.
 The implementer may add or update E2E specs but is explicitly told not to launch a
 browser, start the server, or execute this runner itself.
+The implementer writes its detailed outcome as a run-scoped Markdown artifact and
+returns only a small structured control object containing `status` and the assigned
+artifact path. Norn rejects missing, empty, stale, symlinked, hard-linked, oversized,
+or out-of-contract reports before accepting the provider attempt; changed files are
+derived from Git rather than trusted from the model response.
 The command receives `NORN_E2E_BASE_URL`, `NORN_E2E_EVIDENCE_DIR`, `NORN_RUN_ID`,
 and `NORN_IMPLEMENTATION_ROUND`. It must write at least one non-empty log,
 screenshot, trace, or result file below `NORN_E2E_EVIDENCE_DIR`; Norn's own stdout
 and stderr logs do not count as evidence. Norn owns the authoritative command,
 timeout, exit code, and evidence validation, then gives those results to
-`e2e_tester` for a read-only review with no command tools. The reviewer cannot
-change a failed run into a pass. Managed runners cannot be combined with
+`e2e_tester` for a read-only review with no command tools. The reviewer returns
+only its summary and findings; Norn injects the authoritative test and E2E
+records into the run artifact. Likewise, static testers do not echo a fixed E2E
+placeholder or shared gate results in their structured responses. The reviewer
+cannot change a failed run into a pass. Managed runners cannot be combined with
 `e2e.tcp_forwards` or `--allow-e2e-danger-full-access` because execution occurs in
 Norn's process, outside a tester provider sandbox.
 

{norn_cli-0.8.2 → norn_cli-0.8.3}/README.md

@@ -114,6 +114,43 @@ removed when testing ends.
 For distributable projects, prefer a reviewed, repository-owned E2E command over
 granting a model browser or host permissions:
 
+```bash
+# Adapt the one detected Playwright/Cypress suite. This is a dry run.
+norn init-e2e --adapter existing --project /path/to/repository
+
+# Or scaffold a new Playwright entrypoint in a selected workspace package.
+norn init-e2e --preset playwright --package packages/web --project /path/to/repository
+```
+
+`init-e2e` detects npm, pnpm, yarn, or bun and common E2E scripts/configs. It prints
+the files, minimal Norn YAML, evidence limits, and an optional `git.worktree_setup`
+copy step without changing the repository. Add `--write` after review. Use
+`--external-server` for an already-running Docker/external server, or
+`--server-script NAME` when the project script is not `dev`, `start`, or `serve`.
+`--base-url` must be a loopback HTTP(S) URL.
+
+The existing-suite adapter generates a repository-owned runner and, for Playwright,
+a small config that extends the existing config while disabling its `webServer` so
+Norn remains the only server owner. The Playwright preset additionally creates a
+bounded evidence helper, a smoke spec, a JSON reporter, and low-volume artifact
+defaults. It does not install Playwright unless `--install-dependency` is explicitly
+combined with `--write`; existing framework versions and fixtures remain owned by
+the project.
+
+Re-running `--write` is idempotent. Existing generated files, package scripts, or
+Norn config values are not replaced when they differ; `--force` is the explicit
+migration path. Validate the checked-in contract without launching a browser:
+
+```bash
+norn init-e2e --adapter existing --external-server --check --project /path/to/repository
+norn init-e2e --preset playwright --package packages/web --check --project /path/to/repository
+```
+
+The generated runner receives `NORN_E2E_BASE_URL` and
+`NORN_E2E_EVIDENCE_DIR`, writes its own result record, and keeps evidence within
+the 20-file / 64 MiB limit. Its corresponding configuration is a shell-free argv
+list:
+
 ```yaml
 e2e:
   require_all_testers: false
@@ -128,13 +165,21 @@ Norn runs the four static tester roles in parallel, starts or checks the one sha
 server, then executes `runner.command` exactly once as a shell-free argv list.
 The implementer may add or update E2E specs but is explicitly told not to launch a
 browser, start the server, or execute this runner itself.
+The implementer writes its detailed outcome as a run-scoped Markdown artifact and
+returns only a small structured control object containing `status` and the assigned
+artifact path. Norn rejects missing, empty, stale, symlinked, hard-linked, oversized,
+or out-of-contract reports before accepting the provider attempt; changed files are
+derived from Git rather than trusted from the model response.
 The command receives `NORN_E2E_BASE_URL`, `NORN_E2E_EVIDENCE_DIR`, `NORN_RUN_ID`,
 and `NORN_IMPLEMENTATION_ROUND`. It must write at least one non-empty log,
 screenshot, trace, or result file below `NORN_E2E_EVIDENCE_DIR`; Norn's own stdout
 and stderr logs do not count as evidence. Norn owns the authoritative command,
 timeout, exit code, and evidence validation, then gives those results to
-`e2e_tester` for a read-only review with no command tools. The reviewer cannot
-change a failed run into a pass. Managed runners cannot be combined with
+`e2e_tester` for a read-only review with no command tools. The reviewer returns
+only its summary and findings; Norn injects the authoritative test and E2E
+records into the run artifact. Likewise, static testers do not echo a fixed E2E
+placeholder or shared gate results in their structured responses. The reviewer
+cannot change a failed run into a pass. Managed runners cannot be combined with
 `e2e.tcp_forwards` or `--allow-e2e-danger-full-access` because execution occurs in
 Norn's process, outside a tester provider sandbox.
 

{norn_cli-0.8.2 → norn_cli-0.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "norn-cli"
-version = "0.8.2"
+version = "0.8.3"
 description = "Norn: a provider-neutral multi-agent development harness"
 readme = "README.md"
 license = "Apache-2.0"

{norn_cli-0.8.2 → norn_cli-0.8.3}/src/norf_harness/__init__.py

@@ -3,4 +3,4 @@
 from .config import HarnessConfig, load_config
 
 __all__ = ["HarnessConfig", "load_config"]
-__version__ = "0.8.2"
+__version__ = "0.8.3"

{norn_cli-0.8.2 → norn_cli-0.8.3}/src/norf_harness/cli.py

@@ -14,6 +14,13 @@ import yaml
 from . import __version__
 from .config import ConfigError, default_config_path, load_config, project_config_path
 from .doctor import checks_as_dict, doctor_exit_code, run_doctor
+from .e2e_scaffold import (
+    E2EScaffoldError,
+    apply_e2e_scaffold,
+    build_e2e_scaffold,
+    check_e2e_scaffold,
+    render_e2e_scaffold,
+)
 from .models import ExitCode, RunMode, RunStatus, StopReason
 from .pipeline import execute_pipeline
 from .providers import default_registry
@@ -31,6 +38,23 @@ def build_parser() -> argparse.ArgumentParser:
     _project_option(init_parser)
     init_parser.add_argument("--force", action="store_true")
 
+    e2e_init_parser = subparsers.add_parser(
+        "init-e2e", help="scaffold a project-owned managed E2E runner"
+    )
+    _project_option(e2e_init_parser)
+    setup_mode = e2e_init_parser.add_mutually_exclusive_group(required=True)
+    setup_mode.add_argument("--adapter", choices=("existing",))
+    setup_mode.add_argument("--preset", choices=("playwright",))
+    e2e_init_parser.add_argument("--package", type=Path)
+    e2e_init_parser.add_argument("--base-url", default="http://127.0.0.1:4173")
+    e2e_init_parser.add_argument("--server-script")
+    e2e_init_parser.add_argument("--external-server", action="store_true")
+    action = e2e_init_parser.add_mutually_exclusive_group()
+    action.add_argument("--write", action="store_true")
+    action.add_argument("--check", action="store_true")
+    e2e_init_parser.add_argument("--install-dependency", action="store_true")
+    e2e_init_parser.add_argument("--force", action="store_true")
+
     skill_parser = subparsers.add_parser(
         "install-skill", help="install the bundled Codex and/or Claude skill"
     )
@@ -112,6 +136,8 @@ def main(argv: list[str] | None = None) -> int:
     try:
         if args.command == "init":
             return _init(args)
+        if args.command == "init-e2e":
+            return _init_e2e(args)
         if args.command == "install-skill":
             return _install_skill(args)
         config = load_config(
@@ -146,6 +172,9 @@ def main(argv: list[str] | None = None) -> int:
     except SkillInstallError as exc:
         print(f"SKILL ERROR: {exc}", file=sys.stderr)
         return int(ExitCode.CONFIG_ERROR)
+    except E2EScaffoldError as exc:
+        print(f"E2E SCAFFOLD ERROR: {exc}", file=sys.stderr)
+        return int(ExitCode.CONFIG_ERROR)
     except (RunStoreError, FileNotFoundError) as exc:
         print(f"RUN ERROR: {exc}", file=sys.stderr)
         return int(ExitCode.UNEXPECTED_FAILURE)
@@ -181,6 +210,48 @@ def _install_skill(args: argparse.Namespace) -> int:
     return int(ExitCode.SUCCESS)
 
 
+def _init_e2e(args: argparse.Namespace) -> int:
+    if args.external_server and args.server_script:
+        raise E2EScaffoldError("--external-server cannot be combined with --server-script")
+    if args.install_dependency and args.adapter:
+        raise E2EScaffoldError("--install-dependency is only available with --preset playwright")
+    if args.install_dependency and not args.write:
+        raise E2EScaffoldError("--install-dependency requires --write")
+    if args.check and args.force:
+        raise E2EScaffoldError("--check cannot be combined with --force")
+
+    plan = build_e2e_scaffold(
+        args.project,
+        mode=args.adapter or args.preset,
+        package=args.package,
+        base_url=args.base_url,
+        external_server=args.external_server,
+        server_script=args.server_script,
+        force=args.force,
+    )
+    if args.check:
+        errors = check_e2e_scaffold(plan)
+        if errors:
+            print("E2E scaffold check failed:", file=sys.stderr)
+            for error in errors:
+                print(f"  - {error}", file=sys.stderr)
+            return int(ExitCode.CONFIG_ERROR)
+        print("E2E scaffold valid (browser was not launched)")
+        return int(ExitCode.SUCCESS)
+
+    print(render_e2e_scaffold(plan))
+    if not args.write:
+        print("Dry run only; rerun with --write to create the scaffold.")
+        return int(ExitCode.SUCCESS)
+
+    changed = apply_e2e_scaffold(plan, install_dependency=args.install_dependency)
+    if changed:
+        print(f"Wrote {len(changed)} file(s).")
+    else:
+        print("E2E scaffold already up to date.")
+    return int(ExitCode.SUCCESS)
+
+
 def _ensure_gitignore(root: Path) -> None:
     path = root / ".gitignore"
     markers = (".norf/runs/", ".norf/worktrees/", ".norf/e2e-evidence/")