claude-dev-env 7.0.0 → 7.1.0

package/scripts/local_verification/check_runner.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import TypeAlias
+
+from .check_support import (
+    _prepare_check_invocation,
+    _record_missing_check,
+    _write_logs,
+)
+from .command_runner import run_command as _run_command
+from .config import (
+    CLI_CHECK_FINISH_MESSAGE_TEMPLATE,
+    CLI_CHECK_START_MESSAGE_TEMPLATE,
+    COLLECTED_TESTS_PATTERN,
+    COLLECTION_ERROR_KIND,
+    COLLECTION_STDERR_LOG_SUFFIX,
+    COLLECTION_STDOUT_LOG_SUFFIX,
+    CRASH_ERROR_KIND,
+    FAILED_STATUS,
+    INCOMPLETE_STATUS,
+    MINIMUM_TESTS_ERROR_KIND,
+    NONZERO_EXIT_ERROR_KIND,
+    PASSED_STATUS,
+    PYTEST_COLLECTION_FLAG,
+    PYTEST_QUIET_FLAG,
+    SAFE_LOG_NAME_PATTERN,
+    SKIPPED_TESTS_ERROR_KIND,
+    SKIPPED_TESTS_PATTERN,
+    STDERR_LOG_SUFFIX,
+    STDOUT_LOG_SUFFIX,
+    SUCCESS_EXIT_CODE,
+)
+from .model import (
+    CheckLogPaths,
+    CheckRecord,
+    CheckSpec,
+    CommandCapture,
+    VerificationManifest,
+)
+
+ProgressCallback: TypeAlias = Callable[[str], None]
+
+
+def execute_all_checks(
+    manifest: VerificationManifest,
+    repository_path: Path,
+    base_revision: str,
+    logs_directory: Path,
+    progress_callback: ProgressCallback | None,
+) -> tuple[CheckRecord, ...]:
+    """Execute every check in the manifest.
+
+    Args:
+        manifest: Checks to execute.
+
+    Returns:
+        One record for each check.
+    """
+    return tuple(
+        _execute_check(
+            each_check,
+            repository_path,
+            base_revision,
+            logs_directory,
+            progress_callback,
+        )
+        for each_check in manifest.checks
+    )
+
+
+def _execute_check(
+    check: CheckSpec,
+    repository_path: Path,
+    base_revision: str,
+    logs_directory: Path,
+    progress_callback: ProgressCallback | None,
+) -> CheckRecord:
+    _emit_progress(
+        progress_callback,
+        CLI_CHECK_START_MESSAGE_TEMPLATE.format(check_id=check.check_id),
+    )
+    check_log_paths = _build_check_log_paths(check, logs_directory)
+    check_directory, all_arguments = _prepare_check_invocation(
+        check, repository_path, base_revision
+    )
+    if not check_directory.is_dir():
+        check_record = _record_missing_check(
+            check, all_arguments, check_directory, check_log_paths
+        )
+        return _finish_with_progress(progress_callback, check, check_record)
+    check_record = _run_existing_check(
+        check, all_arguments, check_directory, check_log_paths
+    )
+    return _finish_with_progress(progress_callback, check, check_record)
+
+
+def _build_check_log_paths(check: CheckSpec, logs_directory: Path) -> CheckLogPaths:
+    safe_check_id = SAFE_LOG_NAME_PATTERN.sub("_", check.check_id)
+    return CheckLogPaths(
+        logs_directory / (safe_check_id + STDOUT_LOG_SUFFIX),
+        logs_directory / (safe_check_id + STDERR_LOG_SUFFIX),
+        logs_directory / (safe_check_id + COLLECTION_STDOUT_LOG_SUFFIX),
+        logs_directory / (safe_check_id + COLLECTION_STDERR_LOG_SUFFIX),
+    )
+
+
+def _run_existing_check(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    check_log_paths: CheckLogPaths,
+) -> CheckRecord:
+    all_collection_capture = _collect_minimum_tests(
+        check,
+        all_arguments,
+        check_directory,
+        check_log_paths.collection_stdout,
+        check_log_paths.collection_stderr,
+    )
+    started_at = time.monotonic()
+    command_capture = _run_command(
+        all_arguments, check_directory, check.timeout_seconds
+    )
+    duration_seconds = time.monotonic() - started_at
+    return _finish_check(
+        check,
+        all_arguments,
+        check_directory,
+        check_log_paths,
+        all_collection_capture,
+        command_capture,
+        duration_seconds,
+    )
+
+
+def _finish_with_progress(
+    progress_callback: ProgressCallback | None,
+    check: CheckSpec,
+    check_record: CheckRecord,
+) -> CheckRecord:
+    _emit_progress(
+        progress_callback,
+        CLI_CHECK_FINISH_MESSAGE_TEMPLATE.format(
+            check_id=check.check_id, status=check_record.status
+        ),
+    )
+    return check_record
+
+
+def _emit_progress(
+    progress_callback: ProgressCallback | None, progress_message: str
+) -> None:
+    if progress_callback is not None:
+        progress_callback(progress_message)
+
+
+def _finish_check(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    check_log_paths: CheckLogPaths,
+    all_collection_capture: tuple[CommandCapture, int | None] | None,
+    command_capture: CommandCapture,
+    duration_seconds: float,
+) -> CheckRecord:
+    _write_logs(
+        check_log_paths.stdout,
+        check_log_paths.stderr,
+        command_capture.stdout_text,
+        command_capture.stderr_text,
+    )
+    return _build_finished_record(
+        check,
+        all_arguments,
+        check_directory,
+        check_log_paths,
+        all_collection_capture,
+        command_capture,
+        duration_seconds,
+    )
+
+
+def _build_finished_record(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    check_log_paths: CheckLogPaths,
+    all_collection_capture: tuple[CommandCapture, int | None] | None,
+    command_capture: CommandCapture,
+    duration_seconds: float,
+) -> CheckRecord:
+    status, error_kind, error_message = _classify_record(
+        check, all_collection_capture, command_capture
+    )
+    return CheckRecord(
+        check.check_id,
+        status,
+        all_arguments,
+        str(check_directory),
+        command_capture.exit_code,
+        duration_seconds,
+        check_log_paths.stdout,
+        check_log_paths.stderr,
+        error_kind,
+        error_message,
+        check.minimum_tests,
+        all_collection_capture[1] if all_collection_capture is not None else None,
+        all_collection_capture[0].exit_code
+        if all_collection_capture is not None
+        else None,
+    )
+
+
+def _classify_record(
+    check: CheckSpec,
+    all_collection_capture: tuple[CommandCapture, int | None] | None,
+    command_capture: CommandCapture,
+) -> tuple[str, str | None, str | None]:
+    status, error_kind, error_message = _classify_command(command_capture)
+    if all_collection_capture is None:
+        return status, error_kind, error_message
+    status, error_kind, error_message = _classify_collection(
+        check, all_collection_capture, status, error_kind, error_message
+    )
+    return _classify_skipped_tests(
+        check,
+        all_collection_capture,
+        command_capture,
+        status,
+        error_kind,
+        error_message,
+    )
+
+
+def _collect_minimum_tests(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    stdout_log_path: Path,
+    stderr_log_path: Path,
+) -> tuple[CommandCapture, int | None] | None:
+    if check.minimum_tests is None:
+        return None
+    collection_arguments = _collection_arguments(all_arguments)
+    collection_capture = _run_command(
+        collection_arguments, check_directory, check.timeout_seconds
+    )
+    _write_logs(
+        stdout_log_path,
+        stderr_log_path,
+        collection_capture.stdout_text,
+        collection_capture.stderr_text,
+    )
+    collected_tests = _parse_collected_tests(collection_capture)
+    return collection_capture, collected_tests
+
+
+def _collection_arguments(all_arguments: tuple[str, ...]) -> tuple[str, ...]:
+    all_collection_arguments = list(all_arguments)
+    if PYTEST_COLLECTION_FLAG not in all_collection_arguments:
+        all_collection_arguments.append(PYTEST_COLLECTION_FLAG)
+    if PYTEST_QUIET_FLAG not in all_collection_arguments:
+        all_collection_arguments.append(PYTEST_QUIET_FLAG)
+    return tuple(all_collection_arguments)
+
+
+def _parse_collected_tests(command_capture: CommandCapture) -> int | None:
+    all_text = command_capture.stdout_text + command_capture.stderr_text
+    test_match = COLLECTED_TESTS_PATTERN.search(all_text)
+    if test_match is None:
+        return 0 if command_capture.exit_code == 5 else None
+    return int(test_match.group("count"))
+
+
+def _parse_skipped_tests(command_capture: CommandCapture) -> int:
+    all_text = command_capture.stdout_text + command_capture.stderr_text
+    skipped_match = SKIPPED_TESTS_PATTERN.search(all_text)
+    if skipped_match is None:
+        return 0
+    return int(skipped_match.group("count"))
+
+
+def _classify_skipped_tests(
+    check: CheckSpec,
+    all_collection_capture: tuple[CommandCapture, int | None],
+    command_capture: CommandCapture,
+    status: str,
+    error_kind: str | None,
+    error_message: str | None,
+) -> tuple[str, str | None, str | None]:
+    if status != PASSED_STATUS:
+        return status, error_kind, error_message
+    if not _has_skipped_required_tests(check, all_collection_capture, command_capture):
+        return status, error_kind, error_message
+    return INCOMPLETE_STATUS, SKIPPED_TESTS_ERROR_KIND, "Required tests were skipped"
+
+
+def _has_skipped_required_tests(
+    check: CheckSpec,
+    all_collection_capture: tuple[CommandCapture, int | None],
+    command_capture: CommandCapture,
+) -> bool:
+    if check.minimum_tests is None:
+        return False
+    collection_capture, collected_tests = all_collection_capture
+    if collection_capture.exit_code != SUCCESS_EXIT_CODE:
+        return False
+    if collected_tests is None or collected_tests == 0:
+        return False
+    return _parse_skipped_tests(command_capture) > 0
+
+
+def _classify_collection(
+    check: CheckSpec,
+    all_collection_capture: tuple[CommandCapture, int | None],
+    status: str,
+    error_kind: str | None,
+    error_message: str | None,
+) -> tuple[str, str | None, str | None]:
+    command_capture, collected_tests = all_collection_capture
+    if (
+        check.minimum_tests is not None
+        and collected_tests is not None
+        and collected_tests < check.minimum_tests
+    ):
+        return FAILED_STATUS, MINIMUM_TESTS_ERROR_KIND, "Minimum test count was not met"
+    if status == FAILED_STATUS:
+        return status, error_kind, error_message
+    if command_capture.error_kind is not None:
+        return INCOMPLETE_STATUS, COLLECTION_ERROR_KIND, command_capture.error_message
+    if command_capture.exit_code != SUCCESS_EXIT_CODE:
+        return INCOMPLETE_STATUS, COLLECTION_ERROR_KIND, "Pytest collection failed"
+    if collected_tests is None:
+        return (
+            INCOMPLETE_STATUS,
+            COLLECTION_ERROR_KIND,
+            "Pytest collection count is missing",
+        )
+    return status, error_kind, error_message
+
+
+def _classify_command(
+    command_capture: CommandCapture,
+) -> tuple[str, str | None, str | None]:
+    if command_capture.error_kind is not None:
+        return (
+            INCOMPLETE_STATUS,
+            command_capture.error_kind,
+            command_capture.error_message,
+        )
+    if command_capture.exit_code is None:
+        return INCOMPLETE_STATUS, CRASH_ERROR_KIND, "Command ended without an exit code"
+    if command_capture.exit_code < 0:
+        return INCOMPLETE_STATUS, CRASH_ERROR_KIND, "Command ended from a signal"
+    if command_capture.exit_code != SUCCESS_EXIT_CODE:
+        return (
+            FAILED_STATUS,
+            NONZERO_EXIT_ERROR_KIND,
+            "Command returned a nonzero exit code",
+        )
+    return PASSED_STATUS, None, None

package/scripts/local_verification/check_support.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from .config import (
+    BASE_PLACEHOLDER,
+    CDE_LINT_PLACEHOLDER,
+    INCOMPLETE_STATUS,
+    PYTHON_PLACEHOLDER,
+    REPOSITORY_PLACEHOLDER,
+    REPOSITORY_POLICY_PLACEHOLDER,
+    START_ERROR_KIND,
+    UTF8_ENCODING,
+)
+from .model import CheckLogPaths, CheckRecord, CheckSpec
+
+
+def _prepare_check_invocation(
+    check: CheckSpec, repository_path: Path, base_revision: str
+) -> tuple[Path, tuple[str, ...]]:
+    check_directory = repository_path / check.cwd
+    all_arguments = _substitute_arguments(
+        check.command_arguments, repository_path, base_revision
+    )
+    return check_directory, all_arguments
+
+
+def _record_missing_check(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    check_log_paths: CheckLogPaths,
+) -> CheckRecord:
+    _write_logs(
+        check_log_paths.stdout, check_log_paths.stderr, "", "Missing check directory"
+    )
+    return _incomplete_record(
+        check,
+        all_arguments,
+        check_directory,
+        check_log_paths.stdout,
+        check_log_paths.stderr,
+        START_ERROR_KIND,
+        "Check cwd does not exist",
+    )
+
+
+def _substitute_arguments(
+    all_arguments: tuple[str, ...], repository_path: Path, base_revision: str
+) -> tuple[str, ...]:
+    package_root = Path(__file__).resolve().parents[2]
+    replacement_by_placeholder = {
+        PYTHON_PLACEHOLDER: sys.executable,
+        REPOSITORY_PLACEHOLDER: str(repository_path),
+        BASE_PLACEHOLDER: base_revision,
+        CDE_LINT_PLACEHOLDER: str(package_root / "scripts" / "cde_lint.py"),
+        REPOSITORY_POLICY_PLACEHOLDER: str(
+            package_root / "scripts" / "repository_policy.py"
+        ),
+    }
+    return tuple(
+        replacement_by_placeholder.get(each_argument, each_argument)
+        for each_argument in all_arguments
+    )
+
+
+def _write_logs(
+    stdout_log_path: Path,
+    stderr_log_path: Path,
+    stdout_text: str,
+    stderr_text: str,
+) -> None:
+    stdout_log_path.write_text(stdout_text, encoding=UTF8_ENCODING)
+    stderr_log_path.write_text(stderr_text, encoding=UTF8_ENCODING)
+
+
+def _incomplete_record(
+    check: CheckSpec,
+    all_arguments: tuple[str, ...],
+    check_directory: Path,
+    stdout_log_path: Path,
+    stderr_log_path: Path,
+    error_kind: str,
+    error_message: str,
+) -> CheckRecord:
+    return CheckRecord(
+        check.check_id,
+        INCOMPLETE_STATUS,
+        all_arguments,
+        str(check_directory),
+        None,
+        0.0,
+        stdout_log_path,
+        stderr_log_path,
+        error_kind,
+        error_message,
+        check.minimum_tests,
+    )

package/scripts/local_verification/cli.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Never, TextIO
+
+scripts_directory = Path(__file__).resolve().parents[1]
+if str(scripts_directory) not in sys.path:
+    sys.path.insert(0, str(scripts_directory))
+
+from local_verification.config import (
+    CLI_AGGREGATE_MESSAGE_TEMPLATE,
+    CLI_ELIGIBILITY_MESSAGE_TEMPLATE,
+    CLI_FAILURE_MESSAGE_TEMPLATE,
+    CLI_REPORT_MESSAGE_TEMPLATE,
+    CLI_REVISION_MESSAGE_TEMPLATE,
+    CLI_START_MESSAGE_TEMPLATE,
+    INCOMPLETE_EXIT_CODE,
+    INVALID_INPUT_EXIT_CODE,
+    PASSED_STATUS,
+    REPORT_NEWLINE,
+    UNRESOLVED_REVISION,
+)
+from local_verification.manifest import ManifestRunFatal, load_manifest
+from local_verification.model import VerificationManifest, VerificationReport
+from local_verification.runner import run_verification
+
+
+class _VerificationArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> Never:
+        raise ManifestRunFatal(message)
+
+
+def main(
+    all_arguments: Sequence[str],
+    *,
+    stdout: TextIO = sys.stdout,
+    stderr: TextIO = sys.stderr,
+) -> int:
+    """Run the local verification manifest.
+    Args:
+        all_arguments: Command arguments.
+    Returns:
+        The verifier exit code.
+    """
+    parser = _build_parser()
+    try:
+        parsed_arguments = parser.parse_args(all_arguments)
+    except ManifestRunFatal as error:
+        stderr.write(f"{error}{REPORT_NEWLINE}")
+        return INVALID_INPUT_EXIT_CODE
+    report_path = Path(parsed_arguments.output)
+    if not _clear_previous_report(report_path, stderr):
+        return INCOMPLETE_EXIT_CODE
+    _write_progress(stdout, CLI_START_MESSAGE_TEMPLATE.format(report_path=report_path))
+    manifest = _load_manifest_for_cli(parsed_arguments.manifest, stderr)
+    if manifest is None:
+        return INVALID_INPUT_EXIT_CODE
+    report = _run_manifest_verification(manifest, parsed_arguments, stdout, stderr)
+    if report is None:
+        return INCOMPLETE_EXIT_CODE
+    _write_report_summary(report, report_path, stdout, stderr)
+    return report.exit_code
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = _VerificationArgumentParser(prog="cde verify", add_help=True)
+    parser.add_argument("--manifest", required=True)
+    parser.add_argument("--repo", dest="repository", required=True)
+    parser.add_argument("--base", dest="base_revision", required=True)
+    parser.add_argument("--output", required=True)
+    return parser
+
+
+def _run_manifest_verification(
+    manifest: VerificationManifest,
+    parsed_arguments: argparse.Namespace,
+    stdout: TextIO,
+    stderr: TextIO,
+) -> VerificationReport | None:
+    try:
+        return run_verification(
+            manifest,
+            Path(parsed_arguments.repository),
+            parsed_arguments.base_revision,
+            Path(parsed_arguments.output),
+            progress_callback=lambda progress_message: _write_progress(
+                stdout, progress_message
+            ),
+        )
+    except (OSError, ValueError) as error:
+        stderr.write(f"{error}{REPORT_NEWLINE}")
+        return None
+
+
+def _clear_previous_report(report_path: Path, stderr: TextIO) -> bool:
+    try:
+        report_path.unlink(missing_ok=True)
+    except OSError as error:
+        stderr.write(f"{error}{REPORT_NEWLINE}")
+        return False
+    return True
+
+
+def _write_progress(progress_stream: TextIO, progress_message: str) -> None:
+    progress_stream.write(f"{progress_message}{REPORT_NEWLINE}")
+    progress_stream.flush()
+
+
+def _write_report_summary(
+    report: VerificationReport,
+    report_path: Path,
+    stdout: TextIO,
+    stderr: TextIO,
+) -> None:
+    _write_progress(
+        stdout, CLI_AGGREGATE_MESSAGE_TEMPLATE.format(status=report.aggregate_status)
+    )
+    _write_progress(
+        stdout,
+        CLI_REVISION_MESSAGE_TEMPLATE.format(
+            head=_format_revision(report.head_revision),
+            base=_format_revision(report.base_revision),
+        ),
+    )
+    _write_progress(
+        stdout,
+        CLI_ELIGIBILITY_MESSAGE_TEMPLATE.format(
+            worktree_clean=str(report.worktree_clean).lower(),
+            inputs_unchanged=str(report.inputs_unchanged).lower(),
+            publishable=str(report.publishable).lower(),
+        ),
+    )
+    _write_progress(stdout, CLI_REPORT_MESSAGE_TEMPLATE.format(report_path=report_path))
+    if report.aggregate_status != PASSED_STATUS:
+        stderr.write(
+            f"{CLI_FAILURE_MESSAGE_TEMPLATE.format(status=report.aggregate_status)}{REPORT_NEWLINE}"
+        )
+
+
+def _format_revision(revision: str | None) -> str:
+    return revision or UNRESOLVED_REVISION
+
+
+def _load_manifest_for_cli(
+    manifest_name: str, stderr: TextIO
+) -> VerificationManifest | None:
+    try:
+        return load_manifest(Path(manifest_name))
+    except (ManifestRunFatal, OSError) as error:
+        stderr.write(f"{error}{REPORT_NEWLINE}")
+        return None
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/scripts/local_verification/command_runner.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from .config import (
+    MISSING_TOOL_ERROR_KIND,
+    START_ERROR_KIND,
+    TIMEOUT_ERROR_KIND,
+    UTF8_ENCODING,
+)
+from .model import CommandCapture
+
+
+def run_command(
+    all_arguments: tuple[str, ...], check_directory: Path, timeout_seconds: float
+) -> CommandCapture:
+    """Run a local command and return its captured state.
+
+    Args:
+        all_arguments: Command and its arguments.
+        check_directory: Working directory for the command.
+        timeout_seconds: Wall-clock limit for the command.
+
+    Returns:
+        The captured exit code, output, and error kind.
+    """
+    try:
+        completed_process = _run_subprocess(
+            all_arguments, check_directory, timeout_seconds
+        )
+    except FileNotFoundError as error:
+        return CommandCapture(None, "", "", MISSING_TOOL_ERROR_KIND, str(error))
+    except subprocess.TimeoutExpired as error:
+        return _timeout_capture(error)
+    except (OSError, ValueError) as error:
+        return CommandCapture(None, "", "", START_ERROR_KIND, str(error))
+    return _completed_capture(completed_process)
+
+
+def _timeout_capture(error: subprocess.TimeoutExpired) -> CommandCapture:
+    return CommandCapture(
+        None,
+        _decode_command_text(error.stdout),
+        _decode_command_text(error.stderr),
+        TIMEOUT_ERROR_KIND,
+        "Command exceeded its timeout",
+    )
+
+
+def _completed_capture(
+    completed_process: subprocess.CompletedProcess[str],
+) -> CommandCapture:
+    return CommandCapture(
+        completed_process.returncode,
+        completed_process.stdout,
+        completed_process.stderr,
+        None,
+        None,
+    )
+
+
+def _run_subprocess(
+    all_arguments: tuple[str, ...], check_directory: Path, timeout_seconds: float
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        all_arguments,
+        cwd=check_directory,
+        shell=False,
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding=UTF8_ENCODING,
+        errors="replace",
+        timeout=timeout_seconds,
+    )
+
+
+def _decode_command_text(command_text: str | bytes | None) -> str:
+    if command_text is None:
+        return ""
+    if isinstance(command_text, bytes):
+        return command_text.decode(UTF8_ENCODING, errors="replace")
+    return command_text

package/scripts/local_verification/config/__init__.py

@@ -0,0 +1 @@
+from .constants import *