quantikmind-cli 0.1.0__py3-none-any.whl

quantikmind_cli/scanner.py

@@ -0,0 +1,547 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+import re
+import subprocess
+import sys
+from typing import Any, Iterable
+
+
+SYNC_LIBRARY_FRAMEWORKS = ("pytest", "jest", "maven", "gradle", "cypress", "playwright", "robot")
+PYTEST_FILE_RE = re.compile(r"(^test_.*\.py$|.*_test\.py$)")
+JEST_FILE_RE = re.compile(r".*(\.test|\.spec)\.(js|jsx|ts|tsx)$")
+JAVA_TEST_FILE_RE = re.compile(r".*Test\.java$")
+CYPRESS_FILE_RE = re.compile(r".*\.cy\.(js|ts)$")
+PLAYWRIGHT_FILE_RE = re.compile(r".*(\.test|\.spec)\.(js|ts)$")
+JEST_BLOCK_RE = re.compile(
+    r"\b(?P<kind>describe|it|test)(?:\.(?:only|skip|todo|each))?\s*\(\s*(?P<quote>['\"`])(?P<name>.*?)(?P=quote)",
+    re.DOTALL,
+)
+CYPRESS_BLOCK_RE = re.compile(
+    r"\b(?P<kind>describe|context|it|specify)(?:\.(?:only|skip))?\s*\(\s*"
+    r"(?P<quote>['\"`])(?P<name>.*?)(?P=quote)",
+    re.DOTALL,
+)
+PLAYWRIGHT_BLOCK_RE = re.compile(
+    r"\b(?P<kind>test(?:\.describe)?)(?:\.(?:only|skip|fixme))?\s*\(\s*"
+    r"(?P<quote>['\"`])(?P<name>.*?)(?P=quote)",
+    re.DOTALL,
+)
+JAVA_TEST_METHOD_RE = re.compile(
+    r"@Test(?:\s*\([^)]*\))?\s*(?:\r?\n\s*(?:@\w+(?:\([^)]*\))?\s*)*)*"
+    r"(?:public|private|protected)?\s*(?:static\s+)?(?:void|[\w<>\[\], ?]+)\s+(?P<name>\w+)\s*\(",
+    re.MULTILINE,
+)
+COMMON_PATH_PARTS = {
+    "__tests__",
+    "com",
+    "io",
+    "java",
+    "javascript",
+    "js",
+    "jvm",
+    "net",
+    "org",
+    "py",
+    "python",
+    "spec",
+    "specs",
+    "src",
+    "test",
+    "tests",
+    "ts",
+    "typescript",
+    "unit",
+    "integration",
+}
+HIGH_CRITICALITY_HINTS = ("checkout", "payment", "billing", "invoice", "auth", "login", "security")
+CRITICAL_HINTS = ("critical", "p0", "sev0", "prod_down", "outage")
+LOW_CRITICALITY_HINTS = ("smoke", "snapshot", "lint", "format", "style")
+
+
+class LibraryScanError(RuntimeError):
+    """Raised when a functional test library cannot be generated."""
+
+
+@dataclass(frozen=True)
+class DiscoveredTest:
+    test_id: str
+    name: str
+    framework: str
+    path: Path
+    service: str
+    selector: str | None = None
+    suite: str = "default"
+    business_criticality: str | None = None
+
+    def to_payload(self, root: Path) -> dict[str, Any]:
+        relative_path = _relative_posix(self.path, root)
+        payload: dict[str, Any] = {
+            "test_id": self.test_id,
+            "name": self.name,
+            "service": self.service,
+            "suite": self.suite,
+            "framework": self.framework,
+            "repo_ref": {"path": relative_path},
+            "code_mapping": {"file_globs": [relative_path]},
+        }
+        if self.selector:
+            payload["repo_ref"]["selector"] = self.selector
+        if self.business_criticality:
+            payload["business_criticality"] = self.business_criticality
+        return payload
+
+
+@dataclass
+class LibraryScanResult:
+    tests: list[DiscoveredTest] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    def payload(self, root: str | Path) -> list[dict[str, Any]]:
+        root_path = Path(root)
+        return [test.to_payload(root_path) for test in self.tests]
+
+
+def scan_functional_library(
+    framework: str,
+    test_dir: str | Path,
+    *,
+    root: str | Path = ".",
+) -> LibraryScanResult:
+    if framework not in SYNC_LIBRARY_FRAMEWORKS:
+        raise LibraryScanError(f"Unsupported framework for qmind sync library: {framework}")
+
+    root_path = Path(root).resolve()
+    test_root = (root_path / test_dir).resolve()
+    if not test_root.exists():
+        raise LibraryScanError(f"Test directory does not exist: {test_dir}")
+    if not test_root.is_dir():
+        raise LibraryScanError(f"Test path is not a directory: {test_dir}")
+
+    if framework == "pytest":
+        return scan_pytest(test_root, root=root_path)
+    if framework == "jest":
+        return scan_jest(test_root, root=root_path)
+    if framework == "cypress":
+        return scan_cypress(test_root, root=root_path)
+    if framework == "playwright":
+        return scan_playwright(test_root, root=root_path)
+    if framework == "robot":
+        return scan_robot(test_root, root=root_path)
+    return scan_java(framework, test_root, root=root_path)
+
+
+def scan_pytest(test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    collected = _collect_pytest(test_root_path, root=root_path)
+    if collected.tests:
+        return collected
+
+    fallback = _scan_pytest_files(test_root_path, root=root_path)
+    fallback.warnings = [*collected.warnings, *fallback.warnings]
+    return fallback
+
+
+def scan_jest(test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    result = LibraryScanResult()
+
+    for path in _iter_files(test_root_path, JEST_FILE_RE):
+        try:
+            content = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            result.warnings.append(f"Could not parse {path}: file is not UTF-8")
+            continue
+        except OSError as exc:
+            result.warnings.append(f"Could not read {path}: {exc}")
+            continue
+
+        matches = list(JEST_BLOCK_RE.finditer(content))
+        describe_stack: list[str] = []
+        for match in matches:
+            kind = match.group("kind")
+            name = _clean_name(match.group("name"))
+            if not name:
+                continue
+            if kind == "describe":
+                describe_stack = [name]
+                continue
+
+            display_name = " ".join([*describe_stack, name]).strip()
+            selector = display_name or name
+            result.tests.append(
+                _discovered_test(
+                    framework="jest",
+                    path=path,
+                    root=root_path,
+                    test_root=test_root_path,
+                    name=display_name or name,
+                    selector=selector,
+                    test_id=f"{_relative_posix(path, root_path)}::{selector}",
+                )
+            )
+
+    return result
+
+
+def scan_cypress(test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    result = LibraryScanResult()
+
+    for path in _iter_cypress_files(test_root_path):
+        scanned = _scan_js_style_tests(
+            framework="cypress",
+            path=path,
+            root=root_path,
+            test_root=test_root_path,
+            pattern=CYPRESS_BLOCK_RE,
+            suite_kinds={"describe", "context"},
+        )
+        result.tests.extend(scanned.tests)
+        result.warnings.extend(scanned.warnings)
+
+    return result
+
+
+def scan_playwright(test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    result = LibraryScanResult()
+
+    for path in _iter_files(test_root_path, PLAYWRIGHT_FILE_RE):
+        scanned = _scan_js_style_tests(
+            framework="playwright",
+            path=path,
+            root=root_path,
+            test_root=test_root_path,
+            pattern=PLAYWRIGHT_BLOCK_RE,
+            suite_kinds={"test.describe"},
+        )
+        result.tests.extend(scanned.tests)
+        result.warnings.extend(scanned.warnings)
+
+    return result
+
+
+def scan_robot(test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    result = LibraryScanResult()
+
+    for path in sorted(test_root_path.rglob("*.robot")):
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except UnicodeDecodeError:
+            result.warnings.append(f"Could not parse {path}: file is not UTF-8")
+            continue
+        except OSError as exc:
+            result.warnings.append(f"Could not read {path}: {exc}")
+            continue
+
+        in_test_cases = False
+        for line in lines:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            if stripped.startswith("***") and stripped.endswith("***"):
+                section = stripped.strip("*").strip().lower()
+                in_test_cases = section == "test cases"
+                continue
+            if not in_test_cases or line[:1].isspace():
+                continue
+
+            name = _clean_name(stripped)
+            selector = _relative_posix(path, root_path)
+            result.tests.append(
+                _discovered_test(
+                    framework="robot",
+                    path=path,
+                    root=root_path,
+                    test_root=test_root_path,
+                    name=name,
+                    selector=selector,
+                    test_id=f"{selector}::{name}",
+                )
+            )
+
+    return result
+
+
+def scan_java(framework: str, test_root: str | Path, *, root: str | Path = ".") -> LibraryScanResult:
+    root_path = Path(root).resolve()
+    test_root_path = Path(test_root).resolve()
+    result = LibraryScanResult()
+
+    for path in _iter_files(test_root_path, JAVA_TEST_FILE_RE):
+        try:
+            content = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            result.warnings.append(f"Could not parse {path}: file is not UTF-8")
+            continue
+        except OSError as exc:
+            result.warnings.append(f"Could not read {path}: {exc}")
+            continue
+
+        class_name = path.stem
+        for match in JAVA_TEST_METHOD_RE.finditer(content):
+            method_name = match.group("name")
+            selector = f"{class_name}.{method_name}"
+            result.tests.append(
+                _discovered_test(
+                    framework=framework,
+                    path=path,
+                    root=root_path,
+                    test_root=test_root_path,
+                    name=method_name,
+                    selector=selector,
+                    test_id=selector,
+                    suite=class_name,
+                )
+            )
+
+    return result
+
+
+def _scan_js_style_tests(
+    *,
+    framework: str,
+    path: Path,
+    root: Path,
+    test_root: Path,
+    pattern: re.Pattern[str],
+    suite_kinds: set[str],
+) -> LibraryScanResult:
+    result = LibraryScanResult()
+    try:
+        content = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        result.warnings.append(f"Could not parse {path}: file is not UTF-8")
+        return result
+    except OSError as exc:
+        result.warnings.append(f"Could not read {path}: {exc}")
+        return result
+
+    relative_path = _relative_posix(path, root)
+    suite_name: str | None = None
+    for match in pattern.finditer(content):
+        kind = match.group("kind")
+        name = _clean_name(match.group("name"))
+        if not name:
+            continue
+        if kind in suite_kinds:
+            suite_name = name
+            continue
+
+        display_name = " ".join(part for part in (suite_name, name) if part).strip() or name
+        result.tests.append(
+            _discovered_test(
+                framework=framework,
+                path=path,
+                root=root,
+                test_root=test_root,
+                name=display_name,
+                selector=relative_path,
+                test_id=f"{relative_path}::{display_name}",
+            )
+        )
+
+    return result
+
+
+def _collect_pytest(test_root: Path, *, root: Path) -> LibraryScanResult:
+    result = LibraryScanResult()
+    try:
+        completed = subprocess.run(
+            [sys.executable, "-m", "pytest", "--collect-only", "-q", str(test_root)],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            timeout=60,
+            check=False,
+        )
+    except FileNotFoundError:
+        result.warnings.append("pytest is not available; falling back to Python source scanning.")
+        return result
+    except subprocess.SubprocessError as exc:
+        result.warnings.append(f"pytest collection failed: {exc}; falling back to Python source scanning.")
+        return result
+
+    if completed.returncode != 0:
+        details = (completed.stderr or completed.stdout).strip().splitlines()
+        suffix = f": {details[-1]}" if details else ""
+        result.warnings.append(f"pytest collection failed{suffix}; falling back to Python source scanning.")
+        return result
+
+    for line in completed.stdout.splitlines():
+        selector = line.strip()
+        if not selector or "::" not in selector or selector.startswith("<"):
+            continue
+        path_text, name_parts = selector.split("::", 1)
+        path = (root / path_text).resolve()
+        name = name_parts.split("::")[-1]
+        result.tests.append(
+            _discovered_test(
+                framework="pytest",
+                path=path,
+                root=root,
+                test_root=test_root,
+                name=name,
+                selector=selector,
+                test_id=selector,
+                suite=_suite_from_selector(name_parts),
+            )
+        )
+
+    return result
+
+
+def _scan_pytest_files(test_root: Path, *, root: Path) -> LibraryScanResult:
+    result = LibraryScanResult()
+    for path in _iter_files(test_root, PYTEST_FILE_RE):
+        try:
+            tree = ast.parse(path.read_text(encoding="utf-8"))
+        except SyntaxError as exc:
+            result.warnings.append(f"Could not parse {path}: {exc.msg}")
+            continue
+        except UnicodeDecodeError:
+            result.warnings.append(f"Could not parse {path}: file is not UTF-8")
+            continue
+        except OSError as exc:
+            result.warnings.append(f"Could not read {path}: {exc}")
+            continue
+
+        for node in tree.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name.startswith("test_"):
+                selector = f"{_relative_posix(path, root)}::{node.name}"
+                result.tests.append(
+                    _discovered_test(
+                        framework="pytest",
+                        path=path,
+                        root=root,
+                        test_root=test_root,
+                        name=node.name,
+                        selector=selector,
+                        test_id=selector,
+                    )
+                )
+            elif isinstance(node, ast.ClassDef) and node.name.startswith("Test"):
+                for child in node.body:
+                    if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)) and child.name.startswith("test_"):
+                        selector = f"{_relative_posix(path, root)}::{node.name}::{child.name}"
+                        result.tests.append(
+                            _discovered_test(
+                                framework="pytest",
+                                path=path,
+                                root=root,
+                                test_root=test_root,
+                                name=child.name,
+                                selector=selector,
+                                test_id=selector,
+                                suite=node.name,
+                            )
+                        )
+
+    return result
+
+
+def _discovered_test(
+    *,
+    framework: str,
+    path: Path,
+    root: Path,
+    test_root: Path,
+    name: str,
+    selector: str,
+    test_id: str,
+    suite: str = "default",
+) -> DiscoveredTest:
+    service = infer_service(path, root=root, test_root=test_root)
+    return DiscoveredTest(
+        test_id=test_id,
+        name=name,
+        framework=framework,
+        path=path,
+        service=service,
+        selector=selector,
+        suite=suite,
+        business_criticality=infer_business_criticality([name, selector, str(path)]),
+    )
+
+
+def infer_service(path: str | Path, *, root: str | Path = ".", test_root: str | Path | None = None) -> str:
+    root_path = Path(root).resolve()
+    path_obj = Path(path).resolve()
+    try:
+        relative = path_obj.relative_to(Path(test_root).resolve() if test_root else root_path)
+    except ValueError:
+        try:
+            relative = path_obj.relative_to(root_path)
+        except ValueError:
+            relative = path_obj
+
+    parts = list(relative.parts[:-1])
+    lowered = [part.lower() for part in parts]
+    for marker in ("services", "service", "apps", "app", "packages", "modules"):
+        if marker in lowered:
+            index = lowered.index(marker)
+            if index + 1 < len(parts):
+                return _service_name(parts[index + 1])
+
+    candidates = [part for part in parts if part.lower() not in COMMON_PATH_PARTS]
+    if candidates:
+        return _service_name(candidates[-1])
+    return "default"
+
+
+def infer_business_criticality(values: Iterable[str]) -> str:
+    text = " ".join(values).lower()
+    if any(hint in text for hint in CRITICAL_HINTS):
+        return "critical"
+    if any(hint in text for hint in HIGH_CRITICALITY_HINTS):
+        return "high"
+    if any(hint in text for hint in LOW_CRITICALITY_HINTS):
+        return "low"
+    return "medium"
+
+
+def _iter_files(root: Path, pattern: re.Pattern[str]) -> Iterable[Path]:
+    for path in sorted(root.rglob("*")):
+        if path.is_file() and pattern.match(path.name):
+            yield path
+
+
+def _iter_cypress_files(root: Path) -> Iterable[Path]:
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        if CYPRESS_FILE_RE.match(path.name):
+            yield path
+            continue
+        parts = {part.lower() for part in path.parts}
+        if "integration" in parts and path.suffix.lower() in {".js", ".ts"}:
+            yield path
+
+
+def _relative_posix(path: Path, root: Path) -> str:
+    try:
+        return path.resolve().relative_to(root.resolve()).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _suite_from_selector(selector: str) -> str:
+    parts = [part for part in selector.split("::") if part]
+    return parts[-2] if len(parts) > 1 else "default"
+
+
+def _clean_name(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def _service_name(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "-", value).strip("-").lower() or "default"

quantikmind_cli/subset.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping
+
+
+SUBSET_FRAMEWORKS = (
+    "pytest",
+    "jest",
+    "maven",
+    "gradle",
+    "cypress",
+    "playwright",
+    "rspec",
+    "cucumber",
+    "robot",
+)
+
+
+class SubsetError(RuntimeError):
+    """Raised when a selected subset cannot be rendered for test execution."""
+
+
+def selected_test_selectors(
+    response: Mapping[str, Any], *, use_internal_ids: bool = False
+) -> list[str]:
+    selected = response.get("selected")
+    if selected is None:
+        raise SubsetError("Selection response did not include selected tests.")
+    if not isinstance(selected, list):
+        raise SubsetError("Selection response selected field was not a list.")
+
+    selectors: list[str] = []
+    for item in selected:
+        selector = _selector_from_item(item, use_internal_ids=use_internal_ids)
+        if selector:
+            selectors.append(selector)
+    return selectors
+
+
+def format_test_selectors(framework: str, selectors: Iterable[str]) -> str:
+    values = [str(selector).strip() for selector in selectors if str(selector).strip()]
+    if not values:
+        raise SubsetError("No tests were selected by Quantik Mind.")
+
+    if framework in {"pytest", "jest", "rspec", "cucumber", "robot"}:
+        return " ".join(values)
+    if framework == "maven":
+        return f"-Dtest={','.join(values)}"
+    if framework == "gradle":
+        return " ".join(f"--tests {value}" for value in values)
+    if framework == "cypress":
+        return f"--spec {','.join(values)}"
+    if framework == "playwright":
+        return " ".join(values)
+    raise SubsetError(f"Unsupported framework for qmind subset: {framework}")
+
+
+def selection_stats(response: Mapping[str, Any]) -> str | None:
+    counts = response.get("counts")
+    if not isinstance(counts, Mapping):
+        return None
+    total = counts.get("total")
+    selected = counts.get("selected")
+    if total is None or selected is None:
+        return None
+    return f"Quantik Mind selected {selected}/{total} tests."
+
+
+def machine_readable_selection_payload(
+    response: Mapping[str, Any],
+    *,
+    selected_tests: Iterable[str],
+) -> dict[str, Any]:
+    payload = dict(response)
+    payload.setdefault("selected_tests", list(selected_tests))
+
+    business_metrics = payload.get("business_metrics")
+    if isinstance(business_metrics, Mapping):
+        for key in (
+            "risk_coverage",
+            "top_risk_coverage",
+            "residual_risk",
+            "risk_efficiency",
+        ):
+            if key in business_metrics:
+                payload.setdefault(key, business_metrics[key])
+
+    return payload
+
+
+def _selector_from_item(item: Any, *, use_internal_ids: bool = False) -> str | None:
+    if isinstance(item, str):
+        return item.strip() or None
+    if not isinstance(item, Mapping):
+        return None
+
+    keys = (
+        ("internal_test_id", "id", "test_id")
+        if use_internal_ids
+        else ("test_id", "cli_selector", "test_name")
+    )
+    for key in keys:
+        value = item.get(key)
+        if value is not None and str(value).strip():
+            return str(value).strip()
+    return None