quantikmind-cli 0.1.0__py3-none-any.whl

quantikmind_cli/config.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+import yaml
+
+
+DEFAULT_BASE_URL = "https://api.quantikmind.com"
+REPO_CONFIG_FILE = "qmind.yaml"
+CREDENTIALS_DIR = ".qmind"
+CREDENTIALS_FILE = "credentials.yaml"
+AGENT_STATE_FILE = "agent-state.yaml"
+SECRET_KEYS = {"api_key", "token", "access_token", "refresh_token", "secret", "credential"}
+
+
+class ConfigError(RuntimeError):
+    """Raised when CLI configuration cannot be loaded or written."""
+
+
+def repo_config_path(root: str | Path = ".") -> Path:
+    return Path(root) / REPO_CONFIG_FILE
+
+
+def credentials_path(home: str | Path | None = None) -> Path:
+    base = Path(home) if home is not None else Path.home()
+    return base / CREDENTIALS_DIR / CREDENTIALS_FILE
+
+
+def agent_state_path(home: str | Path | None = None) -> Path:
+    base = Path(home) if home is not None else Path.home()
+    return base / CREDENTIALS_DIR / AGENT_STATE_FILE
+
+
+def missing_repo_config(root: str | Path = ".") -> bool:
+    return not repo_config_path(root).exists()
+
+
+def load_repo_config(root: str | Path = ".") -> dict[str, Any]:
+    path = repo_config_path(root)
+    if not path.exists():
+        raise ConfigError(f"Missing repo config: {path}")
+    return _read_yaml_mapping(path)
+
+
+def write_repo_config(config: Mapping[str, Any], root: str | Path = ".") -> Path:
+    sanitized = _strip_secrets(dict(config))
+    path = repo_config_path(root)
+    _write_yaml_mapping(path, sanitized)
+    return path
+
+
+def load_credentials(path: str | Path | None = None) -> dict[str, Any]:
+    credentials_file = Path(path) if path is not None else credentials_path()
+    if not credentials_file.exists():
+        raise ConfigError(f"Missing credentials: {credentials_file}")
+    return _read_yaml_mapping(credentials_file)
+
+
+def write_credentials(
+    credentials: Mapping[str, Any],
+    path: str | Path | None = None,
+) -> Path:
+    credentials_file = Path(path) if path is not None else credentials_path()
+    _write_yaml_mapping(credentials_file, dict(credentials))
+    return credentials_file
+
+
+def load_agent_state(path: str | Path | None = None) -> dict[str, Any]:
+    state_file = Path(path) if path is not None else agent_state_path()
+    if not state_file.exists():
+        return {}
+    return _read_yaml_mapping(state_file)
+
+
+def write_agent_state(state: Mapping[str, Any], path: str | Path | None = None) -> Path:
+    state_file = Path(path) if path is not None else agent_state_path()
+    _write_yaml_mapping(state_file, dict(state))
+    return state_file
+
+
+def resolve_base_url(config: Mapping[str, Any] | None = None) -> str:
+    value = (config or {}).get("api_url") or (config or {}).get("base_url") or DEFAULT_BASE_URL
+    return str(value).rstrip("/")
+
+
+def _read_yaml_mapping(path: Path) -> dict[str, Any]:
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError as exc:
+        raise ConfigError(f"Invalid YAML in {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ConfigError(f"Expected a YAML mapping in {path}")
+    return data
+
+
+def _write_yaml_mapping(path: Path, data: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        yaml.safe_dump(dict(data), sort_keys=False),
+        encoding="utf-8",
+    )
+
+
+def _strip_secrets(data: dict[str, Any]) -> dict[str, Any]:
+    for key, value in list(data.items()):
+        if key.lower() in SECRET_KEYS:
+            data.pop(key)
+        elif isinstance(value, dict):
+            data[key] = _strip_secrets(value)
+    return data

quantikmind_cli/git.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import subprocess
+
+
+class GitError(RuntimeError):
+    """Raised when git metadata cannot be read."""
+
+
+@dataclass(frozen=True)
+class BuildMetadata:
+    commit_hash: str
+    message: str
+    author: str
+    timestamp: str
+    branch: str | None
+    files_changed: list[str]
+
+    @property
+    def short_hash(self) -> str:
+        return self.commit_hash[:7]
+
+
+def get_current_build_metadata() -> BuildMetadata:
+    commit_hash = _git("rev-parse", "HEAD")
+    message = _git("log", "-1", "--format=%B").strip()
+    author = _git("log", "-1", "--format=%an <%ae>")
+    timestamp = _git("log", "-1", "--format=%cI")
+    branch = _current_branch()
+    files_changed = _changed_files()
+
+    if not message:
+        message = commit_hash
+
+    return BuildMetadata(
+        commit_hash=commit_hash,
+        message=message,
+        author=author,
+        timestamp=timestamp,
+        branch=branch,
+        files_changed=files_changed,
+    )
+
+
+def _current_branch() -> str | None:
+    branch = _git("branch", "--show-current")
+    if branch:
+        return branch
+
+    fallback = _git("rev-parse", "--abbrev-ref", "HEAD")
+    if fallback and fallback != "HEAD":
+        return fallback
+    return None
+
+
+def _changed_files() -> list[str]:
+    try:
+        output = _git("diff", "--name-only", "HEAD~1", "HEAD")
+    except GitError:
+        output = _git("diff-tree", "--no-commit-id", "--name-only", "-r", "--root", "HEAD")
+    return [line.strip() for line in output.splitlines() if line.strip()]
+
+
+def _git(*args: str) -> str:
+    try:
+        completed = subprocess.run(
+            ("git", *args),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError as exc:
+        raise GitError("Git is not installed or is not available on PATH.") from exc
+    except subprocess.CalledProcessError as exc:
+        detail = (exc.stderr or exc.stdout or "").strip()
+        command = "git " + " ".join(args)
+        message = f"Git command failed: {command}"
+        if detail:
+            message = f"{message}: {detail}"
+        raise GitError(message) from exc
+
+    return completed.stdout.strip()

quantikmind_cli/manifest.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+BUSINESS_CRITICALITIES = {"low", "medium", "high", "critical"}
+REQUIRED_FIELDS = ("test_id", "name", "framework", "service")
+OPTIONAL_PAYLOAD_FIELDS = (
+    "repo_ref",
+    "code_mapping",
+    "tags",
+    "markers",
+    "metadata",
+    "file",
+    "path",
+    "test_level",
+    "timeout_ms",
+    "parallelizable",
+    "constraints",
+    "avg_duration_ms",
+)
+DURATION_FIELDS = ("avg_duration_ms", "duration_ms", "estimated_duration_ms")
+
+
+class ManifestImportError(RuntimeError):
+    """Raised when an enterprise test manifest cannot be imported."""
+
+
+def load_manifest_payload(path: str | Path) -> list[dict[str, Any]]:
+    manifest_path = Path(path)
+    if not manifest_path.exists():
+        raise ManifestImportError(f"Manifest file does not exist: {manifest_path}")
+    if not manifest_path.is_file():
+        raise ManifestImportError(f"Manifest path is not a file: {manifest_path}")
+
+    data = _read_manifest(manifest_path)
+    if not isinstance(data, dict):
+        raise ManifestImportError("Manifest top-level value must be an object with a tests list.")
+
+    tests = data.get("tests")
+    if not isinstance(tests, list):
+        raise ManifestImportError("Manifest must include top-level tests as a list.")
+
+    payload: list[dict[str, Any]] = []
+    for index, item in enumerate(tests):
+        if not isinstance(item, dict):
+            raise ManifestImportError(f"Manifest test at index {index} must be an object.")
+        payload.append(_manifest_test_payload(item, index))
+    return payload
+
+
+def _read_manifest(path: Path) -> Any:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ManifestImportError(f"Could not read manifest {path}: {exc}") from exc
+
+    if path.suffix.lower() == ".json":
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise ManifestImportError(f"Invalid JSON in manifest {path}: {exc}") from exc
+
+    try:
+        return yaml.safe_load(text)
+    except yaml.YAMLError as exc:
+        raise ManifestImportError(f"Invalid YAML in manifest {path}: {exc}") from exc
+
+
+def _manifest_test_payload(item: dict[str, Any], index: int) -> dict[str, Any]:
+    normalized = _normalize_manifest_item(item)
+    missing = [field for field in REQUIRED_FIELDS if _blank(normalized.get(field))]
+    if missing:
+        fields = ", ".join(missing)
+        raise ManifestImportError(f"Manifest test at index {index} is missing required field(s): {fields}.")
+
+    criticality = str(normalized.get("business_criticality") or "medium").strip().lower()
+    if criticality not in BUSINESS_CRITICALITIES:
+        allowed = ", ".join(sorted(BUSINESS_CRITICALITIES))
+        raise ManifestImportError(
+            f"Manifest test at index {index} has invalid business_criticality "
+            f"{criticality!r}. Allowed values: {allowed}."
+        )
+
+    payload: dict[str, Any] = {
+        "test_id": str(normalized["test_id"]).strip(),
+        "name": str(normalized["name"]).strip(),
+        "framework": str(normalized["framework"]).strip(),
+        "service": str(normalized["service"]).strip(),
+        "suite": str(normalized.get("suite") or "default").strip() or "default",
+        "business_criticality": criticality,
+    }
+    for field in OPTIONAL_PAYLOAD_FIELDS:
+        if field in normalized and normalized[field] is not None:
+            payload[field] = normalized[field]
+    return payload
+
+
+def _normalize_manifest_item(item: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(item)
+    if "test_id" not in normalized and "id" in normalized:
+        normalized["test_id"] = normalized["id"]
+    if "name" not in normalized and normalized.get("test_id") is not None:
+        normalized["name"] = normalized["test_id"]
+    if "business_criticality" not in normalized and "criticality" in normalized:
+        normalized["business_criticality"] = normalized["criticality"]
+    if "tags" not in normalized and "markers" in normalized:
+        normalized["tags"] = normalized["markers"]
+    duration = _resolve_duration_ms(normalized)
+    if duration is not None:
+        normalized["avg_duration_ms"] = duration
+    return normalized
+
+
+def _blank(value: Any) -> bool:
+    return value is None or str(value).strip() == ""
+
+
+def _resolve_duration_ms(item: dict[str, Any]) -> int | float | None:
+    for field in DURATION_FIELDS:
+        value = item.get(field)
+        if value is not None and not _blank(value):
+            return value
+
+    constraints = item.get("constraints")
+    if isinstance(constraints, dict):
+        value = constraints.get("estimated_duration_ms")
+        if value is not None and not _blank(value):
+            return value
+    return None

quantikmind_cli/record_tests.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+import re
+import xml.etree.ElementTree as ET
+from typing import Any
+
+JUNIT_BROWSER_PREFIXES = ("chromium", "firefox", "webkit")
+PATH_LIKE_TEST_EXTENSIONS = (
+    ".py",
+    ".cy.js",
+    ".cy.ts",
+    ".spec.js",
+    ".spec.ts",
+    ".test.js",
+    ".test.ts",
+    ".robot",
+)
+
+
+class ResultsImportError(RuntimeError):
+    """Raised when test result records cannot be loaded."""
+
+
+@dataclass
+class ResultsParseResult:
+    records: list[dict[str, Any]] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+
+def collect_junit_records(results_dir: str | Path) -> ResultsParseResult:
+    root = Path(results_dir)
+    if not root.exists():
+        raise ResultsImportError(f"Results directory does not exist: {root}")
+    if not root.is_dir():
+        raise ResultsImportError(f"Results path is not a directory: {root}")
+
+    files = [path for path in root.rglob("*") if path.is_file()]
+    result = ResultsParseResult()
+    if not files:
+        result.warnings.append(f"Results directory is empty: {root}")
+        return result
+
+    for path in files:
+        parsed = parse_junit_file(path)
+        result.records.extend(parsed.records)
+        result.warnings.extend(parsed.warnings)
+
+    return result
+
+
+def parse_junit_file(path: str | Path) -> ResultsParseResult:
+    report_path = Path(path)
+    try:
+        xml_root = ET.parse(report_path).getroot()
+    except ET.ParseError as exc:
+        return ResultsParseResult(warnings=[f"Malformed XML in {report_path}: {exc}"])
+    except OSError as exc:
+        return ResultsParseResult(warnings=[f"Could not read {report_path}: {exc}"])
+
+    suite_elements = _suite_elements(xml_root)
+    if not suite_elements:
+        return ResultsParseResult(warnings=[f"Unsupported JUnit XML shape in {report_path}"])
+
+    records: list[dict[str, Any]] = []
+    warnings: list[str] = []
+    fallback_executed_at = _file_mtime_iso(report_path)
+
+    for suite in suite_elements:
+        executed_at = _suite_timestamp(suite) or fallback_executed_at
+        suite_properties = _properties(suite)
+        for testcase in _children_named(suite, "testcase"):
+            record = _record_from_testcase(
+                testcase,
+                executed_at=executed_at,
+                suite_properties=suite_properties,
+            )
+            if record:
+                records.append(record)
+
+    if not records:
+        warnings.append(f"No usable test cases found in {report_path}")
+
+    return ResultsParseResult(records=records, warnings=warnings)
+
+
+def _suite_elements(root: ET.Element) -> list[ET.Element]:
+    if _local_name(root.tag) == "testsuite":
+        return [root]
+    if _local_name(root.tag) == "testsuites":
+        return [child for child in _children_named(root, "testsuite")]
+    return []
+
+
+def _record_from_testcase(
+    testcase: ET.Element,
+    *,
+    executed_at: str,
+    suite_properties: dict[str, str] | None = None,
+) -> dict[str, Any] | None:
+    name = _normalize_junit_id_part(testcase.attrib.get("name"))
+    classname = _normalize_junit_id_part(testcase.attrib.get("classname"))
+    if not name:
+        return None
+
+    testcase_properties = {**(suite_properties or {}), **_properties(testcase)}
+    test_id = (
+        _normalize_junit_test_id(testcase_properties.get("test_id"))
+        or _junit_test_id(classname=classname, name=name, file_attr=testcase.attrib.get("file"))
+    )
+    record = {
+        "test_id": test_id,
+        "status": _status_from_testcase(testcase),
+        "duration_ms": _duration_ms(testcase.attrib.get("time")),
+        "executed_at": executed_at,
+    }
+    for key in ("test_name", "service", "commit_sha", "build_id"):
+        value = testcase_properties.get(key)
+        if value:
+            record[key] = value
+    return record
+
+
+def _properties(element: ET.Element) -> dict[str, str]:
+    properties: dict[str, str] = {}
+    for child in _children_named(element, "properties"):
+        for prop in _children_named(child, "property"):
+            name = _normalize_junit_id_part(prop.attrib.get("name"))
+            value = _normalize_junit_id_part(prop.attrib.get("value"))
+            if name and value:
+                properties[name] = value
+    return properties
+
+
+def _junit_test_id(*, classname: str, name: str, file_attr: str | None) -> str:
+    """Build the primary history identifier without inventing backend aliases.
+
+    Prefer IDs that match `qmind sync library` scanner output when JUnit exposes
+    enough identity. Keep generic JUnit fallback deterministic instead of
+    guessing from ambiguous names alone.
+    """
+    file_path = _safe_junit_file_path(file_attr) or _safe_junit_file_path(classname)
+    if file_path:
+        return f"{file_path}::{name}"
+    pytest_id = _pytest_junit_test_id(classname=classname, name=name)
+    if pytest_id:
+        return pytest_id
+    java_id = _java_junit_test_id(classname=classname, name=name)
+    if java_id:
+        return java_id
+    if classname:
+        return _normalize_junit_test_id(f"{classname}.{name}")
+    return _normalize_junit_test_id(name)
+
+
+def _normalize_junit_test_id(value: str | None) -> str:
+    return _normalize_junit_id_part(value)
+
+
+def _normalize_junit_id_part(value: str | None) -> str:
+    normalized = re.sub(r"\s+", " ", str(value or "").replace("\\", "/")).strip()
+    return normalized
+
+
+def _safe_junit_file_path(value: str | None) -> str | None:
+    text = _normalize_junit_id_part(value)
+    if not text:
+        return None
+
+    parts = text.split(" ", 1)
+    if len(parts) == 2 and parts[0].lower() in JUNIT_BROWSER_PREFIXES:
+        return _path_token_if_supported(parts[1])
+
+    direct = _path_token_if_supported(text)
+    if direct:
+        return direct
+
+    return None
+
+
+def _pytest_junit_test_id(*, classname: str, name: str) -> str | None:
+    if not classname or not name.startswith("test_"):
+        return None
+
+    parts = [part for part in classname.split(".") if part]
+    if not parts or not _looks_like_pytest_module(parts):
+        return None
+
+    class_name: str | None = None
+    module_parts = parts
+    if parts[-1].startswith("Test"):
+        class_name = parts[-1]
+        module_parts = parts[:-1]
+
+    if not module_parts:
+        return None
+
+    module_path = "/".join(module_parts) + ".py"
+    if class_name:
+        return f"{module_path}::{class_name}::{name}"
+    return f"{module_path}::{name}"
+
+
+def _looks_like_pytest_module(parts: list[str]) -> bool:
+    return any(part.startswith("test_") or part.endswith("_test") for part in parts)
+
+
+def _java_junit_test_id(*, classname: str, name: str) -> str | None:
+    if not classname or not name or name.startswith("test_"):
+        return None
+
+    class_name = classname.rsplit(".", 1)[-1]
+    if not class_name.endswith("Test"):
+        return None
+
+    return f"{class_name}.{name}"
+
+
+def _path_token_if_supported(value: str) -> str | None:
+    candidate = value.strip()
+    if "/" not in candidate:
+        return None
+    lowered = candidate.lower()
+    if any(lowered.endswith(extension) for extension in PATH_LIKE_TEST_EXTENSIONS):
+        return candidate
+    if "/cypress/integration/" in f"/{lowered}" and lowered.endswith((".js", ".ts")):
+        return candidate
+    return None
+
+
+def _status_from_testcase(testcase: ET.Element) -> str:
+    child_names = {_local_name(child.tag) for child in list(testcase)}
+    if "failure" in child_names or "error" in child_names:
+        return "failed"
+    if "skipped" in child_names:
+        return "skipped"
+    return "passed"
+
+
+def _duration_ms(value: str | None) -> int:
+    if value is None or not str(value).strip():
+        return 0
+    try:
+        seconds = float(str(value).strip())
+    except ValueError:
+        return 0
+    if seconds < 0:
+        return 0
+    return int(round(seconds * 1000))
+
+
+def _suite_timestamp(suite: ET.Element) -> str | None:
+    timestamp = (suite.attrib.get("timestamp") or "").strip()
+    return timestamp or None
+
+
+def _file_mtime_iso(path: Path) -> str:
+    return datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat()
+
+
+def _children_named(element: ET.Element, local_name: str) -> list[ET.Element]:
+    return [child for child in list(element) if _local_name(child.tag) == local_name]
+
+
+def _local_name(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]