wup 0.2.24__tar.gz → 0.2.26__tar.gz

{wup-0.2.24/wup.egg-info → wup-0.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.24
+Version: 0.2.26
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -29,17 +29,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.22-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$1.86-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-11.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.26-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$1.95-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-15.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $1.8607 (34 commits)
-- 👤 **Human dev:** ~$1113 (11.1h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $1.9540 (36 commits)
+- 👤 **Human dev:** ~$1532 (15.3h @ $100/h, 30min dedup)
 
-Generated on 2026-05-12 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-16 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.22-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.26-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.24 → wup-0.2.26}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.22-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$1.86-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-11.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.26-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$1.95-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-15.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $1.8607 (34 commits)
-- 👤 **Human dev:** ~$1113 (11.1h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $1.9540 (36 commits)
+- 👤 **Human dev:** ~$1532 (15.3h @ $100/h, 30min dedup)
 
-Generated on 2026-05-12 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-16 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.22-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.26-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.24 → wup-0.2.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wup"
-version = "0.2.24"
+version = "0.2.26"
 description = "WUP (What's Up) - Intelligent file watcher for regression testing in large projects"
 readme = "README.md"
 requires-python = ">=3.9"

wup-0.2.26/tests/test_monitoring_manifest.py

@@ -0,0 +1,72 @@
+import tempfile
+from pathlib import Path
+
+import yaml
+
+from wup.models.config import ProjectConfig, ServiceConfig, TestQLConfig, WupConfig, WatchConfig
+from wup.monitoring_manifest import (
+    MANIFEST_BEGIN,
+    MANIFEST_END,
+    build_monitoring_manifest,
+    discover_docker_compose_services,
+    load_monitoring_manifest_from_yaml,
+    patch_wup_yaml_monitoring,
+)
+
+
+def test_discover_docker_compose():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir)
+        (root / "docker-compose.yml").write_text(
+            "services:\n"
+            "  firmware:\n"
+            "    container_name: test-simulator-firmware\n"
+            "    ports:\n"
+            "      - '8202:8202'\n"
+            "    healthcheck:\n"
+            "      test: ['CMD', 'curl', 'http://127.0.0.1:8202/health']\n",
+            encoding="utf-8",
+        )
+        found = discover_docker_compose_services(root)
+        assert len(found) == 1
+        assert found[0].compose_service == "firmware"
+        assert found[0].container_name == "test-simulator-firmware"
+
+
+def test_patch_and_load_monitoring_block():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir)
+        (root / "docker-compose.yml").write_text(
+            "services:\n  firmware:\n    container_name: test-simulator-firmware\n    ports:\n      - '8202:8202'\n",
+            encoding="utf-8",
+        )
+        cfg_path = root / "wup.yaml"
+        cfg_path.write_text(
+            "project:\n  name: demo\n"
+            "services:\n  - name: firmware\n    paths: ['backend/firmware/**']\n"
+            "testql:\n  base_url: http://localhost:8100\n"
+            "  endpoints_by_service:\n    firmware:\n      - /firmware/api/v1/health\n",
+            encoding="utf-8",
+        )
+        wup_config = WupConfig(
+            project=ProjectConfig(name="demo"),
+            services=[ServiceConfig(name="firmware", paths=["backend/firmware/**"])],
+            watch=WatchConfig(),
+            testql=TestQLConfig(
+                base_url="http://localhost:8100",
+                endpoints_by_service={"firmware": ["/firmware/api/v1/health"]},
+                probe_interval_s=60,
+            ),
+        )
+        manifest = build_monitoring_manifest(root, wup_config)
+        patch_wup_yaml_monitoring(cfg_path, manifest)
+
+        text = cfg_path.read_text(encoding="utf-8")
+        assert MANIFEST_BEGIN in text
+        assert MANIFEST_END in text
+
+        loaded = load_monitoring_manifest_from_yaml(cfg_path)
+        assert loaded is not None
+        assert loaded["wup_services"]["firmware"]["live_probes"]
+        assert loaded["wup_services"]["firmware"]["live_probes"][0]["url"].endswith("/firmware/api/v1/health")
+        assert loaded["wup_services"]["firmware"]["docker"][0]["compose_service"] == "firmware"

wup-0.2.26/tests/test_testql_monitor.py

@@ -0,0 +1,121 @@
+import asyncio
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from wup.models.config import ProjectConfig, ServiceConfig, TestQLConfig, WupConfig, WatchConfig
+from wup.testql_monitor import (
+    ProbeTarget,
+    TestQLMonitor,
+    assign_probe_to_service,
+    is_monitoring_probe,
+    parse_scenario_probes,
+    parse_service_map_probes,
+)
+from wup.testql_watcher import TestQLWatcher
+
+
+def test_parse_scenario_probes_full_url():
+    content = """
+API[1]{method, endpoint, expected_status}:
+  GET, http://localhost:8100/firmware/api/v1/health, 200
+"""
+    with tempfile.NamedTemporaryFile("w", suffix=".testql.toon.yaml", delete=False) as handle:
+        handle.write(content)
+        handle.flush()
+        path = Path(handle.name)
+
+    probes = parse_scenario_probes(path)
+    path.unlink(missing_ok=True)
+    assert len(probes) == 1
+    assert probes[0].url.endswith("/firmware/api/v1/health")
+    assert probes[0].expected_status == 200
+    assert is_monitoring_probe(probes[0])
+
+
+def test_assign_firmware_service():
+    services = [
+        ServiceConfig(name="frontend", paths=["frontend/**"]),
+        ServiceConfig(name="firmware", paths=["backend/firmware/**"]),
+    ]
+    probe = ProbeTarget(url="http://localhost:8100/firmware/api/v1/health")
+    assert assign_probe_to_service(probe, services) == "firmware"
+
+
+def test_monitor_merges_config_and_service_map():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir)
+        scenario_dir = root / "testql-scenarios"
+        scenario_dir.mkdir()
+        scenario = scenario_dir / "fleet-health.testql.toon.yaml"
+        scenario.write_text(
+            "API[1]{method, endpoint, expected_status}:\n"
+            "  GET, http://localhost:8100/firmware/api/v1/execution/status, 200\n",
+            encoding="utf-8",
+        )
+
+        service_map = root / "service-map.yaml"
+        service_map.write_text(
+            "service:\n  base_url: http://localhost:8100\n"
+            "endpoints:\n"
+            "  - { method: GET, path: /firmware/api/v1/health }\n",
+            encoding="utf-8",
+        )
+
+        cfg = WupConfig(
+            project=ProjectConfig(name="demo"),
+            services=[
+                ServiceConfig(name="firmware", paths=["backend/firmware/**"]),
+            ],
+            watch=WatchConfig(),
+            testql=TestQLConfig(
+                scenario_dir="testql-scenarios",
+                base_url="http://localhost:8100",
+                endpoint_discovery=True,
+                service_map_globs=["service-map.yaml"],
+                endpoints_by_service={
+                    "firmware": ["/firmware/api/v1/execution/logs"],
+                },
+            ),
+        )
+        monitor = TestQLMonitor(root, cfg)
+        probes = monitor.probes_for_service("firmware")
+        urls = {p.url for p in probes}
+        assert "http://localhost:8100/firmware/api/v1/health" in urls
+        assert "http://localhost:8100/firmware/api/v1/execution/status" in urls
+        assert "http://localhost:8100/firmware/api/v1/execution/logs" in urls
+
+
+def test_live_probe_failure_updates_health():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir)
+        cfg = WupConfig(
+            project=ProjectConfig(name="demo"),
+            services=[ServiceConfig(name="firmware", paths=["backend/firmware/**"])],
+            watch=WatchConfig(),
+            testql=TestQLConfig(
+                scenario_dir="testql-scenarios",
+                base_url="http://localhost:8100",
+                endpoints_by_service={"firmware": ["/firmware/api/v1/health"]},
+            ),
+        )
+        watcher = TestQLWatcher(
+            project_root=str(root),
+            deps_file=str(root / "deps.json"),
+            scenarios_dir="testql-scenarios",
+            config=cfg,
+        )
+
+        failing = ProbeTarget(url="http://localhost:8100/firmware/api/v1/health")
+
+        def fake_probe(self, timeout_s=10.0):
+            return False, "HTTP 500 (expected 200)"
+
+        with patch.object(ProbeTarget, "probe", fake_probe):
+            ok = asyncio.run(watcher._run_live_http_probes("firmware", []))
+
+        assert ok is False
+        state = json.loads((root / ".wup" / "service-health.json").read_text(encoding="utf-8"))
+        assert state["firmware"]["status"] == "down"
+        assert state["firmware"]["stage"] == "probe"

{wup-0.2.24 → wup-0.2.26}/wup/__init__.py

@@ -7,7 +7,7 @@ WUP monitors file changes and runs intelligent regression tests using a 3-layer
 3. Detail Layer: Full tests with blame reports (only on failure)
 """
 
-__version__ = "0.2.22"
+__version__ = "0.2.26"
 __author__ = "Tom Sapletta"
 
 from .config import load_config, save_config, get_default_config

{wup-0.2.24 → wup-0.2.26}/wup/cli.py

@@ -9,7 +9,7 @@ from typing import Optional
 import typer
 from rich.console import Console
 
-from .config import load_config
+from .config import find_config_file, load_config
 from .core import WupWatcher
 from .dependency_mapper import DependencyMapper
 from .models.config import WupConfig
@@ -37,6 +37,11 @@ def watch(
     browser_service_url: Optional[str] = typer.Option(None, "--browser-service-url", help="HTTP endpoint for browser notifications"),
     track_dir: str = typer.Option(".wup/tracks", "--track-dir", help="Directory where error track JSON files are written"),
     quick_limit: int = typer.Option(3, "--quick-limit", help="Maximum TestQL scenarios used in quick pass"),
+    probe_interval: Optional[int] = typer.Option(
+        None,
+        "--probe-interval",
+        help="Periodic live HTTP/TestQL probes in seconds (overrides testql.probe_interval_s)",
+    ),
     config: Optional[str] = typer.Option(None, "--config", "-C", help="Path to wup.yaml config file"),
 ):
     """
@@ -56,16 +61,30 @@ def watch(
     # Load configuration
     config_path = Path(config) if config else None
     wup_config = load_config(project_path, config_path)
-    
+    if probe_interval is not None:
+        wup_config.testql.probe_interval_s = int(probe_interval)
+
     console.print(f"[bold cyan]🚀 WUP Watcher[/bold cyan]")
     console.print(f"[dim]Project: {wup_config.project.name}[/dim]")
     console.print(f"[dim]Description: {wup_config.project.description}[/dim]")
     console.print(f"[dim]CPU Throttle: {cpu_throttle * 100}%[/dim]")
     console.print(f"[dim]Debounce: {debounce}s[/dim]")
     console.print(f"[dim]Cooldown: {cooldown}s[/dim]")
+    if wup_config.testql.probe_interval_s:
+        console.print(f"[dim]Live probes: every {wup_config.testql.probe_interval_s}s[/dim]")
     console.print(f"[dim]Config: {config_path or 'auto-detected'}[/dim]")
     console.print()
     
+    cfg_path = config_path if config_path and config_path.exists() else find_config_file(project_path)
+    if cfg_path:
+        from .monitoring_manifest import build_monitoring_manifest, patch_wup_yaml_monitoring
+        try:
+            manifest = build_monitoring_manifest(project_path, wup_config)
+            patch_wup_yaml_monitoring(cfg_path, manifest)
+            console.print("[dim]Refreshed monitoring manifest in wup.yaml[/dim]")
+        except OSError as exc:
+            console.print(f"[yellow]Could not refresh monitoring manifest: {exc}[/yellow]")
+
     if mode.lower() == "testql":
         watcher = TestQLWatcher(
             project_root=str(project_path),
@@ -274,6 +293,33 @@ def status(
                     if track_file:
                         lines.append(Text.from_markup(f"    [dim]track: {track_file}[/dim]"))
 
+        # --- monitoring manifest (from wup.yaml) ---
+        manifest_path = config_path if config_path and config_path.exists() else find_config_file(project_path)
+        if manifest_path:
+            from .monitoring_manifest import load_monitoring_manifest_from_yaml
+
+            manifest = load_monitoring_manifest_from_yaml(manifest_path)
+            if manifest:
+                lines.append(Text(""))
+                lines.append(Text.from_markup("[bold]Configured monitoring (wup.yaml):[/bold]"))
+                lines.append(Text.from_markup(
+                    f"  [dim]manifest {manifest.get('generated_at', '?')} · "
+                    f"probe {manifest.get('probe_interval_s', 0)}s[/dim]"
+                ))
+                for svc, info in sorted((manifest.get("wup_services") or {}).items()):
+                    probes = info.get("live_probes") or []
+                    dockers = info.get("docker") or []
+                    lines.append(Text.from_markup(
+                        f"  [cyan]{svc}[/cyan]: {len(probes)} probe(s), docker: "
+                        + ", ".join(
+                            d.get("compose_service", "?") for d in dockers[:4]
+                        )
+                        + ("…" if len(dockers) > 4 else "")
+                    ))
+                lines.append(Text.from_markup(
+                    "  [dim]Pełna lista: sekcja monitoring: w wup.yaml (BEGIN WUP MONITORING MANIFEST)[/dim]"
+                ))
+
         # --- visual diff section ---
         if wup_config.visual_diff and wup_config.visual_diff.enabled:
             from .visual_diff import VisualDiffer
@@ -439,6 +485,91 @@ def map_deps(
     console.print(f"[dim]Files: {len(deps.get('files', {}))}[/dim]")
 
 
+@app.command("sync-testql")
+def sync_testql(
+    project: str = typer.Argument(".", help="Path to the project root directory"),
+    write: bool = typer.Option(False, "--write", "-w", help="Write monitoring manifest block into wup.yaml"),
+    merge_endpoints: bool = typer.Option(
+        False,
+        "--merge-endpoints",
+        help="Also merge discovered paths into testql.endpoints_by_service (rewrites YAML body)",
+    ),
+    config: Optional[str] = typer.Option(None, "--config", "-C", help="Path to wup.yaml config file"),
+):
+    """
+    Discover monitoring targets and document them in wup.yaml.
+
+    With ``--write``, appends/updates the auto-generated ``monitoring:`` block
+    (Docker Compose services, live HTTP probes, sources). Use this to verify
+    whether a failure is a WUP config gap vs a down container.
+
+    Use ``--merge-endpoints`` cautiously — it re-serializes wup.yaml (may drop comments).
+    """
+    import json
+
+    from .config import find_config_file, load_config
+    from .monitoring_manifest import (
+        MANIFEST_BEGIN,
+        build_monitoring_manifest,
+        format_manifest_summary,
+        patch_wup_yaml_monitoring,
+    )
+    from .testql_monitor import TestQLMonitor
+
+    project_path = Path(project).resolve()
+    if not project_path.exists():
+        console.print(f"[red]Error: Project path '{project}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    config_path = Path(config) if config else find_config_file(project_path)
+    wup_config = load_config(project_path, config_path)
+    monitor = TestQLMonitor(project_path, wup_config)
+    suggested = monitor.suggested_endpoints_by_service()
+    manifest = build_monitoring_manifest(project_path, wup_config)
+
+    console.print("[bold]Monitoring manifest (preview):[/bold]")
+    console.print(format_manifest_summary(manifest))
+
+    if suggested:
+        console.print()
+        console.print("[bold]Suggested testql.endpoints_by_service additions:[/bold]")
+        console.print(json.dumps(suggested, indent=2))
+
+    if not write:
+        console.print()
+        console.print("[dim]Run: wup sync-testql . --write  → dokumentacja w wup.yaml[/dim]")
+        return
+
+    if config_path is None:
+        console.print("[red]No wup.yaml found — run `wup init` first[/red]")
+        raise typer.Exit(1)
+
+    if merge_endpoints and suggested:
+        import yaml as pyyaml
+
+        merged = dict(wup_config.testql.endpoints_by_service or {})
+        for service, paths in suggested.items():
+            existing = set(merged.get(service, []))
+            existing.update(paths)
+            merged[service] = sorted(existing)
+        raw = pyyaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+        raw.setdefault("testql", {})["endpoints_by_service"] = merged
+        wup_config.testql.endpoints_by_service = merged
+        manifest = build_monitoring_manifest(project_path, wup_config)
+        body = pyyaml.safe_dump(
+            {k: v for k, v in raw.items() if k != "monitoring"},
+            sort_keys=False,
+            allow_unicode=True,
+            default_flow_style=False,
+        )
+        config_path.write_text(body.rstrip() + "\n\n", encoding="utf-8")
+        console.print("[yellow]Merged endpoints_by_service (review git diff for comment loss)[/yellow]")
+
+    patch_wup_yaml_monitoring(config_path, manifest)
+    console.print(f"[green]✓ monitoring manifest written to {config_path}[/green]")
+    console.print(f"[dim]Szukaj w pliku: {MANIFEST_BEGIN}[/dim]")
+
+
 @app.command()
 def assistant(
     quick: bool = typer.Option(False, "--quick", "-q", help="Non-interactive mode with auto-detected values"),

{wup-0.2.24 → wup-0.2.26}/wup/config.py

@@ -176,6 +176,9 @@ def validate_config(raw: dict) -> WupConfig:
         output_format=testql_raw.get("output_format", "json"),
         extra_args=testql_raw.get("extra_args", ["--timeout 10s"]),
         endpoint_discovery=testql_raw.get("endpoint_discovery", True),
+        probe_interval_s=int(testql_raw.get("probe_interval_s", 0) or 0),
+        health_scenario=testql_raw.get("health_scenario", ""),
+        service_map_globs=testql_raw.get("service_map_globs", []),
         base_url=testql_raw.get("base_url", ""),
         base_url_env=testql_raw.get("base_url_env", "WUP_BASE_URL"),
         explicit_endpoints=testql_raw.get("explicit_endpoints", []),
@@ -328,6 +331,9 @@ def save_config(config: WupConfig, output_path: Path):
             "output_format": config.testql.output_format,
             "extra_args": config.testql.extra_args,
             "endpoint_discovery": config.testql.endpoint_discovery,
+            "probe_interval_s": config.testql.probe_interval_s,
+            "health_scenario": config.testql.health_scenario,
+            "service_map_globs": config.testql.service_map_globs,
             "base_url": config.testql.base_url,
             "base_url_env": config.testql.base_url_env,
             "explicit_endpoints": config.testql.explicit_endpoints,

{wup-0.2.24 → wup-0.2.26}/wup/core.py

@@ -6,6 +6,8 @@ import asyncio
 import json
 import subprocess
 import time
+import urllib.error
+import urllib.request
 from collections import defaultdict, deque
 from pathlib import Path
 from typing import Dict, List, Optional, Set, Tuple
@@ -298,69 +300,96 @@ class WupWatcher:
     async def run_quick_test(self, service: str, endpoints: List[str]) -> bool:
         """
         Run a quick test for a service (smoke test).
-        
+
         Args:
             service: Service name
             endpoints: List of endpoints to test
-            
+
         Returns:
             True if all tests passed, False otherwise
         """
         self.console.print(f"[cyan]🧪 Quick testing {service} ({len(endpoints)} endpoints)[/cyan]")
-        
-        # This is a placeholder - integrate with TestQL or your test framework
-        # For now, simulate a test
-        await asyncio.sleep(1)
-        
-        # Simulate random failure for demo (10% chance)
-        import random
-        passed = random.random() > 0.1
-        
+
+        if not endpoints:
+            self.console.print(f"[yellow]⚠ No endpoints configured for {service}, skipping quick test[/yellow]")
+            return True
+
+        passed = True
+        for endpoint in endpoints:
+            try:
+                req = urllib.request.Request(endpoint, method="HEAD")
+                with urllib.request.urlopen(req, timeout=10) as resp:
+                    if resp.status >= 400:
+                        self.console.print(f"[red]✗ {endpoint} → HTTP {resp.status}[/red]")
+                        passed = False
+                    else:
+                        self.console.print(f"[green]✓ {endpoint} → HTTP {resp.status}[/green]")
+            except Exception as e:
+                self.console.print(f"[red]✗ {endpoint} → {e}[/red]")
+                passed = False
+
         if passed:
             self.console.print(f"[green]✓ Quick test passed for {service}[/green]")
         else:
             self.console.print(f"[red]✗ Quick test failed for {service}[/red]")
-        
+
         return passed
     
     async def run_detail_test(self, service: str, endpoints: List[str]) -> Dict:
         """
         Run a detailed test for a service with blame report.
-        
+
         Args:
             service: Service name
             endpoints: List of endpoints to test
-            
+
         Returns:
             Dictionary with test results and blame information
         """
         self.console.print(f"[cyan]🔍 Detail testing {service} ({len(endpoints)} endpoints)[/cyan]")
-        
-        # This is a placeholder - integrate with TestQL or your test framework
-        # For now, simulate a test
-        await asyncio.sleep(3)
-        
-        # Simulate results
+
         results = {
             "service": service,
             "total_endpoints": len(endpoints),
-            "passed": len(endpoints) - 1,
-            "failed": 1,
-            "failed_endpoint": endpoints[0] if endpoints else None,
-            "blame": {
-                "file": f"app/{service}/routes.py",
-                "line": 42,
-                "commit": "abc123",
-                "author": "developer"
-            }
+            "passed": 0,
+            "failed": 0,
+            "failed_endpoint": None,
+            "blame": {},
         }
-        
+
+        for endpoint in endpoints:
+            try:
+                req = urllib.request.Request(endpoint, method="GET")
+                with urllib.request.urlopen(req, timeout=30) as resp:
+                    if resp.status >= 400:
+                        results["failed"] += 1
+                        self.console.print(f"[red]✗ {endpoint} → HTTP {resp.status}[/red]")
+                    else:
+                        results["passed"] += 1
+                        self.console.print(f"[green]✓ {endpoint} → HTTP {resp.status}[/green]")
+            except Exception as e:
+                results["failed"] += 1
+                self.console.print(f"[red]✗ {endpoint} → {e}[/red]")
+
         if results["failed"] > 0:
+            results["failed_endpoint"] = endpoints[0] if endpoints else None
+            try:
+                blame_result = subprocess.run(
+                    ["git", "log", "--oneline", "-5", "--", f"*/{service}/*"],
+                    cwd=str(self.project_root),
+                    capture_output=True,
+                    text=True,
+                )
+                if blame_result.returncode == 0:
+                    lines = blame_result.stdout.strip().split("\n")
+                    if lines and lines[0]:
+                        results["blame"] = {"recent_commits": lines}
+            except Exception:
+                pass
             self.console.print(f"[red]✗ Detail test found {results['failed']} regression(s)[/red]")
-            self.console.print(f"[red]  Blame: {results['blame']['file']}:{results['blame']['line']}[/red]")
         else:
             self.console.print(f"[green]✓ Detail test passed for {service}[/green]")
-        
+
         return results
     
     async def test_loop(self):

{wup-0.2.24 → wup-0.2.26}/wup/models/config.py

@@ -60,7 +60,10 @@ class TestQLConfig:
     smoke_scenario: str = "smoke.testql.toon.yaml"
     output_format: str = "json"
     extra_args: List[str] = field(default_factory=lambda: ["--timeout 10s"])
-    endpoint_discovery: bool = True  # Enable automatic endpoint discovery from scenarios
+    endpoint_discovery: bool = True  # Merge health probes from scenarios + service maps
+    probe_interval_s: int = 0  # Periodic live probes for all services (0 = file-change only)
+    health_scenario: str = ""  # Optional TestQL scenario run live (not --dry-run) on each quick pass
+    service_map_globs: List[str] = field(default_factory=list)  # e.g. testql-testing/service-map/*.yaml
     base_url: str = ""
     base_url_env: str = "WUP_BASE_URL"
     explicit_endpoints: List[str] = field(default_factory=list)