engineering-process 0.1.0__py3-none-any.whl

engineering_process/managed.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import re
+
+from .contracts import ContractError
+from .markdown import (
+    contains_raw_html,
+    mask_nonvisible_markdown_blocks,
+    strip_html_comments,
+)
+
+
+AGENTS_START = "<!-- engineering-process:start -->"
+AGENTS_END = "<!-- engineering-process:end -->"
+_AGENTS_START_TOKEN = "ENGINEERING_PROCESS_MANAGED_AGENTS_START"
+_AGENTS_END_TOKEN = "ENGINEERING_PROCESS_MANAGED_AGENTS_END"
+
+
+def _normalized_markdown(text: str) -> str:
+    return text.lstrip("\ufeff").replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _agents_span(text: str) -> tuple[int, int]:
+    if text.count(AGENTS_START) != 1 or text.count(AGENTS_END) != 1:
+        raise ContractError("AGENTS.md: invalid engineering-process managed block")
+    starts = list(re.finditer(rf"(?m)^{re.escape(AGENTS_START)}$", text))
+    ends = list(re.finditer(rf"(?m)^{re.escape(AGENTS_END)}$", text))
+    if len(starts) != 1 or len(ends) != 1:
+        raise ContractError("AGENTS.md: managed markers must each occupy their own line")
+    if starts[0].end() >= ends[0].start():
+        raise ContractError(
+            "AGENTS.md: engineering-process managed markers are out of order"
+        )
+    return starts[0].start(), ends[0].end()
+
+
+def managed_agents_block(text: str) -> str:
+    normalized = _normalized_markdown(text)
+    start, end = _agents_span(normalized)
+    return normalized[start:end]
+
+
+def managed_agents_visibility_issues(text: str) -> list[str]:
+    text = _normalized_markdown(text)
+    try:
+        _agents_span(text)
+    except ContractError as error:
+        return [str(error)]
+    if _AGENTS_START_TOKEN in text or _AGENTS_END_TOKEN in text:
+        return ["AGENTS.md contains reserved engineering-process marker text"]
+    visible = text.replace(AGENTS_START, _AGENTS_START_TOKEN).replace(
+        AGENTS_END, _AGENTS_END_TOKEN
+    )
+    visible, malformed_comments = strip_html_comments(visible)
+    if malformed_comments:
+        return ["AGENTS.md contains an unterminated or malformed HTML comment"]
+    if contains_raw_html(visible):
+        return [
+            "AGENTS.md must not contain raw HTML; use visible CommonMark outside "
+            "the managed markers"
+        ]
+    structural = mask_nonvisible_markdown_blocks(visible)
+    lines = structural.splitlines()
+    starts = [
+        index for index, line in enumerate(lines) if line == _AGENTS_START_TOKEN
+    ]
+    ends = [index for index, line in enumerate(lines) if line == _AGENTS_END_TOKEN]
+    if len(starts) != 1 or len(ends) != 1 or starts[0] >= ends[0]:
+        return [
+            "AGENTS.md managed block must be visible and outside comments, code fences, "
+            "or non-visible Markdown blocks"
+        ]
+    return []
+
+
+def merge_managed_agents(current: str, block: str) -> str:
+    canonical = managed_agents_block(block).strip()
+    current = _normalized_markdown(current)
+    start_count = current.count(AGENTS_START)
+    end_count = current.count(AGENTS_END)
+    if start_count == 0 and end_count == 0:
+        if not current.strip():
+            return canonical + "\n"
+        return current.rstrip() + "\n\n" + canonical + "\n"
+    start, end = _agents_span(current)
+    prefix = current[:start].rstrip()
+    suffix = current[end:].strip()
+    parts = [part for part in (prefix, canonical, suffix) if part]
+    return "\n\n".join(parts) + "\n"

engineering_process/markdown.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+import re
+import unicodedata
+
+from markdown_it import MarkdownIt
+from markdown_it.token import Token
+
+from .runtime import assert_runtime_dependencies
+
+
+assert_runtime_dependencies()
+
+
+COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
+RAW_HTML_LIKE_LINE_RE = re.compile(r"(?m)^ {0,3}<(?:/?[A-Za-z]|[!?])")
+_COMMONMARK = MarkdownIt("commonmark", {"html": True})
+_NONVISIBLE_BLOCK_TYPES = {"code_block", "fence", "html_block"}
+
+
+def strip_html_comments(text: str) -> tuple[str, bool]:
+    visible = COMMENT_RE.sub("", text)
+    malformed = "<!--" in visible or "-->" in visible
+    return visible, malformed
+
+
+def mask_nonvisible_markdown_blocks(text: str) -> str:
+    """Mask source lines CommonMark renders as code or raw HTML blocks."""
+
+    lines = text.splitlines()
+    hidden: set[int] = set()
+    for token in _COMMONMARK.parse(text):
+        if token.type not in _NONVISIBLE_BLOCK_TYPES or token.map is None:
+            continue
+        start, end = token.map
+        hidden.update(range(start, end))
+    return "\n".join("" if index in hidden else line for index, line in enumerate(lines))
+
+
+def _walk_tokens(tokens: list[Token]) -> Iterator[Token]:
+    for token in tokens:
+        yield token
+        if token.children:
+            yield from _walk_tokens(token.children)
+
+
+def contains_raw_html(text: str) -> bool:
+    return RAW_HTML_LIKE_LINE_RE.search(text) is not None or any(
+        token.type in {"html_block", "html_inline"}
+        for token in _walk_tokens(_COMMONMARK.parse(text))
+    )
+
+
+def _inline_text(tokens: list[Token]) -> str:
+    pieces: list[str] = []
+    for token in tokens:
+        if token.children:
+            pieces.append(_inline_text(token.children))
+        elif token.type in {"text", "code_inline"}:
+            pieces.append(token.content)
+        elif token.type in {"softbreak", "hardbreak"}:
+            pieces.append(" ")
+        elif token.type == "image":
+            pieces.append(token.content)
+    return "".join(pieces)
+
+
+def normalized_rendered_inline_text(text: str) -> str:
+    """Return formatting-insensitive CommonMark inline text for policy checks."""
+
+    rendered = _inline_text(_COMMONMARK.parseInline(text))
+    normalized = unicodedata.normalize("NFKC", rendered)
+    normalized = "".join(
+        " " if unicodedata.category(character) == "Cf" else character
+        for character in normalized
+    )
+    return " ".join(normalized.split()).casefold()

engineering_process/publication.py

@@ -0,0 +1,463 @@
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from .contracts import ContractError
+from .markdown import (
+    COMMENT_RE,
+    contains_raw_html,
+    mask_nonvisible_markdown_blocks,
+    normalized_rendered_inline_text,
+    strip_html_comments,
+)
+
+
+CONVENTIONAL_SUBJECT_MAX_LENGTH = 72
+CONVENTIONAL_SUBJECT_RE = re.compile(
+    r"^[a-z]+(?:\([a-z0-9-]+\))?!?: \S(?:.*\S)?$"
+)
+MANUAL_BRANCH_RE = re.compile(
+    r"^(?:feat|fix|docs|refactor|test|chore|build|ci|perf)/"
+    r"[a-z0-9]+(?:-[a-z0-9]+)*$"
+)
+AUTOMATION_BRANCH_RE = re.compile(
+    r"^automation/[a-z0-9]+(?:-[a-z0-9]+)*/"
+    r"[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$"
+)
+GIT_RANGE_RE = re.compile(
+    r"^[0-9A-Za-z][0-9A-Za-z._/~^-]*(?:\.\.\.?[0-9A-Za-z][0-9A-Za-z._/~^-]*)?$"
+)
+HEADING_RE = re.compile(r"^##\s+(.+?)\s*$", re.MULTILINE)
+CHECKBOX_RE = re.compile(
+    r"^\s*-\s+\[(?P<state>[ xX])\]\s+\*\*(?P<label>[^*]+)\*\*(?P<detail>.*)$",
+    re.MULTILINE,
+)
+PROJECT_REQUIREMENT_RE = re.compile(
+    r"^- \[(?P<state>[ xX])\] \*\*Project-specific: "
+    r"(?P<label>[A-Za-z0-9][A-Za-z0-9 /_.-]{0,99})\*\* "
+    r"— (?P<detail>\S.*)$"
+)
+CHECKLIST_STATUS_RE = re.compile(
+    r"\[status:\s*(?P<status>[a-z-]+)\]\s*$", re.IGNORECASE
+)
+CHECKLIST_REASON_RE = re.compile(
+    r"\[reason:\s*(?P<reason>[^\]]*\S[^\]]*)\]", re.IGNORECASE
+)
+CHECKLIST_STATUSES = {"satisfied", "not-applicable", "pending"}
+PR_DESCRIPTION_START = "<!-- engineering-process:pr-description:start -->"
+PR_DESCRIPTION_END = "<!-- engineering-process:pr-description:end -->"
+_START_TOKEN = "ENGINEERING_PROCESS_MANAGED_PR_DESCRIPTION_START"
+_END_TOKEN = "ENGINEERING_PROCESS_MANAGED_PR_DESCRIPTION_END"
+RAW_HTML_BLOCK_RE = re.compile(r"(?m)^ {0,3}</?[A-Za-z][^>]*>")
+REQUIRED_SECTIONS = (
+    "Summary",
+    "Contract and scope",
+    "Impact and risk",
+    "Verification",
+    "Independent review",
+    "Requirements and rules followed",
+)
+REQUIRED_REQUIREMENTS = (
+    "Scope and contract",
+    "Verification evidence",
+    "Independent review",
+)
+STANDARD_REQUIREMENT_DETAILS = {
+    "Scope and contract": (
+        "— accepted scope is implemented without unapproved expansion."
+    ),
+    "Verification evidence": (
+        "— required current profiles pass on the published checkpoint."
+    ),
+    "Independent review": (
+        "— a separate reviewer approved the published checkpoint with no open "
+        "required finding."
+    ),
+}
+
+
+def _normalized_markdown(text: str) -> str:
+    return text.lstrip("\ufeff").replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _policy_key(text: str) -> str:
+    return "".join(
+        character
+        for character in normalized_rendered_inline_text(text)
+        if character.isalnum()
+    )
+
+
+def validate_conventional_subject(subject: str, *, label: str) -> list[str]:
+    stripped = subject.strip()
+    if not stripped:
+        return [f"{label} is empty; use Conventional Commit style"]
+    issues: list[str] = []
+    if subject != stripped or CONVENTIONAL_SUBJECT_RE.fullmatch(stripped) is None:
+        issues.append(
+            f"{label} must use Conventional Commit style: "
+            "`type(scope): subject` or `type: subject`"
+        )
+    if len(stripped) > CONVENTIONAL_SUBJECT_MAX_LENGTH:
+        issues.append(
+            f"{label} must be at most {CONVENTIONAL_SUBJECT_MAX_LENGTH} characters "
+            f"({len(stripped)} found)"
+        )
+    if stripped.endswith("."):
+        issues.append(f"{label} must not end with a period")
+    return issues
+
+
+def validate_commit_subject(subject: str) -> list[str]:
+    return validate_conventional_subject(subject, label="Commit subject")
+
+
+def validate_pr_title(title: str) -> list[str]:
+    return validate_conventional_subject(title, label="PR title")
+
+
+def is_automation_branch(branch: str) -> bool:
+    return AUTOMATION_BRANCH_RE.fullmatch(branch.strip()) is not None
+
+
+def validate_branch(branch: str) -> list[str]:
+    stripped = branch.strip()
+    if not stripped:
+        return ["PR branch is empty"]
+    if branch != stripped:
+        return ["PR branch must not contain surrounding whitespace"]
+    if MANUAL_BRANCH_RE.fullmatch(stripped) or AUTOMATION_BRANCH_RE.fullmatch(stripped):
+        return []
+    return [
+        "PR branch must be `{type}/{kebab-description}` or "
+        "`automation/{owner}/{description}`"
+    ]
+
+
+def _sections(body: str) -> tuple[dict[str, str], list[str]]:
+    matches = list(HEADING_RE.finditer(body))
+    result: dict[str, str] = {}
+    duplicates: list[str] = []
+    for index, match in enumerate(matches):
+        name = match.group(1).strip()
+        start = match.end()
+        end = matches[index + 1].start() if index + 1 < len(matches) else len(body)
+        if name in result:
+            duplicates.append(name)
+        result[name] = body[start:end]
+    return result, duplicates
+
+
+def _visible(text: str) -> str:
+    return COMMENT_RE.sub("", text).strip()
+
+
+def _managed_span(text: str) -> tuple[int, int]:
+    if text.count(PR_DESCRIPTION_START) != 1 or text.count(PR_DESCRIPTION_END) != 1:
+        raise ContractError(
+            "PR body must contain exactly one engineering-process managed block"
+        )
+    start_matches = list(
+        re.finditer(
+            rf"(?m)^{re.escape(PR_DESCRIPTION_START)}$",
+            text,
+        )
+    )
+    end_matches = list(
+        re.finditer(
+            rf"(?m)^{re.escape(PR_DESCRIPTION_END)}$",
+            text,
+        )
+    )
+    if len(start_matches) != 1 or len(end_matches) != 1:
+        raise ContractError("PR managed markers must each occupy their own line")
+    start = start_matches[0]
+    end = end_matches[0]
+    if start.end() >= end.start():
+        raise ContractError("PR managed block markers are out of order")
+    return start.start(), end.end()
+
+
+def managed_pull_request_block(text: str) -> str:
+    normalized = _normalized_markdown(text)
+    start, end = _managed_span(normalized)
+    return normalized[start:end]
+
+
+def merge_managed_pull_request_template(current: str, block: str) -> str:
+    canonical = managed_pull_request_block(block).strip()
+    current = _normalized_markdown(current)
+    if PR_DESCRIPTION_START not in current and PR_DESCRIPTION_END not in current:
+        if current.strip():
+            raise ContractError(
+                ".github/PULL_REQUEST_TEMPLATE.md: existing unmanaged template must "
+                "be migrated around the engineering-process managed block"
+            )
+        return canonical + "\n"
+    start, end = _managed_span(current)
+    prefix = current[:start].rstrip()
+    suffix = current[end:].strip()
+    parts = [part for part in (canonical, prefix, suffix) if part]
+    return "\n\n".join(parts) + "\n"
+
+
+def _visible_managed_content(body: str) -> tuple[str | None, list[str]]:
+    try:
+        start, _ = _managed_span(body)
+    except ContractError as error:
+        return None, [str(error)]
+    if body[:start].strip():
+        return None, [
+            "PR managed block must be the first non-whitespace content; append project "
+            "extensions after it"
+        ]
+    if _START_TOKEN in body or _END_TOKEN in body:
+        return None, ["PR body contains reserved engineering-process marker text"]
+    visible = body.replace(PR_DESCRIPTION_START, _START_TOKEN).replace(
+        PR_DESCRIPTION_END, _END_TOKEN
+    )
+    visible, malformed_comments = strip_html_comments(visible)
+    if malformed_comments:
+        return None, ["PR body contains an unterminated or malformed HTML comment"]
+    if contains_raw_html(visible):
+        return None, ["PR body must not contain raw HTML"]
+    structural = mask_nonvisible_markdown_blocks(visible)
+    lines = structural.splitlines()
+    starts = [index for index, line in enumerate(lines) if line.strip() == _START_TOKEN]
+    ends = [index for index, line in enumerate(lines) if line.strip() == _END_TOKEN]
+    if len(starts) != 1 or len(ends) != 1 or starts[0] >= ends[0]:
+        return None, [
+            "PR managed block must be visible and must not be inside a code fence or comment"
+        ]
+    managed = "\n".join(lines[starts[0] + 1 : ends[0]])
+    if RAW_HTML_BLOCK_RE.search(managed):
+        return None, ["PR managed block must not contain raw HTML block elements"]
+    return managed, []
+
+
+def managed_pull_request_visibility_issues(body: str) -> list[str]:
+    _, issues = _visible_managed_content(_normalized_markdown(body))
+    return issues
+
+
+PROJECT_EXTENSION_HEADING = "## Project-specific requirements"
+
+
+def validate_project_extensions(body: str, *, allow_pending: bool) -> list[str]:
+    body = _normalized_markdown(body)
+    _, end = _managed_span(body)
+    extension = body[end:]
+    if not extension.strip():
+        return []
+    if contains_raw_html(extension):
+        return ["PR extension must not contain raw HTML"]
+    lines = extension.strip().splitlines()
+    if not lines or lines[0] != PROJECT_EXTENSION_HEADING:
+        return [
+            "PR extension must use only the supported project-specific checklist grammar"
+        ]
+    issues: list[str] = []
+    labels: set[str] = set()
+    requirements = 0
+    for line in lines[1:]:
+        if not line:
+            continue
+        match = PROJECT_REQUIREMENT_RE.fullmatch(line)
+        if match is None:
+            issues.append(
+                "Unsupported PR extension content; use `- [ ] **Project-specific: "
+                "Label** — detail. [status: pending]`"
+            )
+            continue
+        requirements += 1
+        label = match.group("label").strip()
+        folded = label.casefold()
+        if folded in labels:
+            issues.append(f"Duplicate project-specific requirement: {label}")
+        labels.add(folded)
+        normalized_line = _policy_key(line)
+        if any(
+            _policy_key(required) in normalized_line
+            for required in REQUIRED_REQUIREMENTS
+        ):
+            issues.append(
+                "Project-specific requirement must not restate reserved core policy: "
+                + label
+            )
+        line_status = CHECKLIST_STATUS_RE.search(line)
+        if line_status is None:
+            issues.append(f"Project-specific requirement is missing a status: {line}")
+            continue
+        status = line_status.group("status").lower()
+        checked = match.group("state").lower() == "x"
+        if status not in CHECKLIST_STATUSES:
+            issues.append(
+                f"Project-specific requirement has invalid status `{status}`: {line}"
+            )
+        elif status == "pending":
+            if checked:
+                issues.append(
+                    f"Pending project-specific requirement must be unchecked: {line}"
+                )
+            if not allow_pending:
+                issues.append(
+                    "Pending project-specific requirement is not ready for publication: "
+                    + line
+                )
+        elif not checked:
+            issues.append(
+                f"Resolved project-specific requirement must be checked: {line}"
+            )
+        if (
+            status == "not-applicable"
+            and CHECKLIST_REASON_RE.search(line) is None
+        ):
+            issues.append(
+                "Not-applicable project-specific requirement must include "
+                f"`[reason: ...]`: {line}"
+            )
+    if requirements == 0:
+        issues.append("PR extension must contain a project-specific checklist item")
+    return issues
+
+
+def validate_pr_body(body: str, *, allow_pending: bool) -> list[str]:
+    body = _normalized_markdown(body)
+    if not _visible(body):
+        return ["PR body is empty; use the managed pull-request template"]
+    managed, marker_issues = _visible_managed_content(body)
+    if managed is None:
+        return marker_issues
+    headings = [match.group(1).strip() for match in HEADING_RE.finditer(managed)]
+    issues = list(marker_issues)
+    if tuple(headings) != REQUIRED_SECTIONS:
+        issues.append(
+            "Managed PR sections must exactly match the canonical order: "
+            + ", ".join(f"## {name}" for name in REQUIRED_SECTIONS)
+        )
+    sections, duplicates = _sections(managed)
+    issues.extend(
+        f"Duplicate section: ## {name}" for name in sorted(set(duplicates))
+    )
+    for required in REQUIRED_SECTIONS:
+        if required not in sections:
+            issues.append(f"Missing section: ## {required}")
+        elif required != "Requirements and rules followed" and not _visible(
+            sections[required]
+        ):
+            issues.append(f"Section must be filled in: ## {required}")
+
+    requirements = sections.get("Requirements and rules followed", "")
+    checkboxes = list(CHECKBOX_RE.finditer(requirements))
+    labels = [match.group("label").strip() for match in checkboxes]
+    if tuple(labels) != REQUIRED_REQUIREMENTS:
+        issues.append(
+            "Managed standard requirements must exactly match the canonical order: "
+            + ", ".join(REQUIRED_REQUIREMENTS)
+        )
+    for required in REQUIRED_REQUIREMENTS:
+        count = labels.count(required)
+        if count == 0:
+            issues.append(f"Missing standard requirement: {required}")
+        elif count > 1:
+            issues.append(f"Duplicate standard requirement: {required}")
+
+    for match in checkboxes:
+        line = match.group(0).strip()
+        label = match.group("label").strip()
+        checked = match.group("state").lower() == "x"
+        status_match = CHECKLIST_STATUS_RE.search(line)
+        if status_match is None:
+            issues.append(f"Requirement is missing a structured status: {line}")
+            continue
+        status = status_match.group("status").lower()
+        if status not in CHECKLIST_STATUSES:
+            issues.append(f"Requirement has invalid status `{status}`: {line}")
+            continue
+        detail = match.group("detail").strip()
+        detail_without_status = CHECKLIST_STATUS_RE.sub("", detail).strip()
+        reason_match = CHECKLIST_REASON_RE.search(detail_without_status)
+        if reason_match is not None:
+            if detail_without_status[reason_match.end() :].strip():
+                issues.append(f"Requirement reason must precede its status: {line}")
+            detail_without_status = (
+                detail_without_status[: reason_match.start()].strip()
+            )
+        expected_detail = STANDARD_REQUIREMENT_DETAILS.get(label)
+        if expected_detail is not None and detail_without_status != expected_detail:
+            issues.append(
+                f"Standard requirement text must remain canonical for {label}"
+            )
+        if status == "pending":
+            if checked:
+                issues.append(f"Pending requirement must be unchecked: {line}")
+            if not allow_pending:
+                issues.append(f"Pending requirement is not ready for publication: {line}")
+        elif not checked:
+            issues.append(f"Resolved requirement must be checked: {line}")
+        if status == "not-applicable" and reason_match is None:
+            issues.append(
+                f"Not-applicable requirement must include `[reason: ...]`: {line}"
+            )
+    issues.extend(validate_project_extensions(body, allow_pending=allow_pending))
+    return issues
+
+
+def validate_pull_request(
+    *, title: str, body: str, branch: str, state: str
+) -> list[str]:
+    if state not in {"draft", "ready"}:
+        raise ContractError("pull-request state must be draft or ready")
+    allow_pending = state == "draft"
+    return [
+        *validate_branch(branch),
+        *validate_pr_title(title),
+        *validate_pr_body(body, allow_pending=allow_pending),
+    ]
+
+
+def commit_subjects(project_root: Path, range_spec: str) -> list[tuple[str, str]]:
+    if GIT_RANGE_RE.fullmatch(range_spec) is None:
+        raise ContractError(f"invalid Git revision or range: {range_spec}")
+    try:
+        result = subprocess.run(
+            ["git", "log", "--format=%H%x00%s", range_spec, "--"],
+            cwd=project_root,
+            check=False,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired) as error:
+        raise ContractError(f"cannot inspect commit range {range_spec}: {error}") from error
+    if result.returncode != 0:
+        detail = result.stderr.decode("utf-8", errors="replace").strip()
+        raise ContractError(
+            f"cannot inspect commit range {range_spec}"
+            + (f": {detail}" if detail else "")
+        )
+    records: list[tuple[str, str]] = []
+    for line in result.stdout.decode("utf-8", errors="replace").splitlines():
+        commit, separator, subject = line.partition("\0")
+        if not separator:
+            raise ContractError("git returned an invalid commit record")
+        records.append((commit, subject))
+    if not records:
+        raise ContractError(f"commit range {range_spec} is empty")
+    return records
+
+
+def validate_commit_range(
+    project_root: Path, *, branch: str, range_spec: str
+) -> tuple[list[str], list[tuple[str, str]]]:
+    records = commit_subjects(project_root, range_spec)
+    issues = validate_branch(branch)
+    for commit, subject in records:
+        issues.extend(
+            f"Commit {commit[:12]}: {issue}"
+            for issue in validate_commit_subject(subject)
+        )
+    return issues, records

engineering_process/requirements-build.txt

@@ -0,0 +1 @@
+setuptools==84.0.0

engineering_process/requirements-dev.txt

@@ -0,0 +1,10 @@
+attrs==26.1.0
+build==1.5.0
+colorama==0.4.6; os_name == "nt"
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+packaging==26.3
+pyproject_hooks==1.2.0
+referencing==0.37.0
+rpds-py==2026.6.3
+typing-extensions==4.15.0; python_version < "3.13"

engineering_process/requirements-runtime.txt

@@ -0,0 +1,3 @@
+markdown-it-py==4.2.0
+mdurl==0.1.2
+regex==2026.7.19