context-engineering-cli 2.6.0__py3-none-any.whl

context_engineering/infra/git_tree.py

@@ -0,0 +1,139 @@
+"""Read an exact Git tree through a temporary, disposable filesystem view."""
+
+from __future__ import annotations
+
+import os
+import posixpath
+import stat
+import subprocess
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from tempfile import TemporaryDirectory
+
+
+@dataclass(frozen=True)
+class _TreeEntry:
+    mode: str
+    object_id: str
+    path: str
+
+
+def _tree_entries(repo: Path, commit: str) -> tuple[list[_TreeEntry], str | None]:
+    try:
+        result = subprocess.run(
+            ["git", "ls-tree", "-r", "-z", "--full-tree", commit],
+            cwd=repo,
+            capture_output=True,
+            check=False,
+            timeout=120,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return [], f"could not read Git tree: {exc}"
+    if result.returncode != 0:
+        message = os.fsdecode(result.stderr).strip() or "git ls-tree failed"
+        return [], message
+    entries: list[_TreeEntry] = []
+    for record in result.stdout.split(b"\0"):
+        if not record:
+            continue
+        metadata, separator, raw_path = record.partition(b"\t")
+        fields = metadata.split()
+        if not separator or len(fields) != 3:
+            return [], "git ls-tree returned a malformed record"
+        mode, object_type, object_id = (os.fsdecode(field) for field in fields)
+        path = os.fsdecode(raw_path)
+        pure = PurePosixPath(path)
+        if pure.is_absolute() or any(part in {"", ".", ".."} for part in pure.parts):
+            return [], f"git tree contains an unsafe path: {path!r}"
+        if object_type == "blob":
+            entries.append(_TreeEntry(mode=mode, object_id=object_id, path=path))
+        elif mode == "160000":
+            entries.append(_TreeEntry(mode=mode, object_id=object_id, path=path))
+    return entries, None
+
+
+def _read_blobs(
+    repo: Path, entries: list[_TreeEntry]
+) -> tuple[dict[str, bytes], str | None]:
+    object_ids = list(dict.fromkeys(entry.object_id for entry in entries if entry.mode != "160000"))
+    if not object_ids:
+        return {}, None
+    try:
+        result = subprocess.run(
+            ["git", "cat-file", "--batch"],
+            cwd=repo,
+            input=("\n".join(object_ids) + "\n").encode(),
+            capture_output=True,
+            check=False,
+            timeout=120,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return {}, f"could not read Git blobs: {exc}"
+    if result.returncode != 0:
+        message = os.fsdecode(result.stderr).strip() or "git cat-file failed"
+        return {}, message
+    blobs: dict[str, bytes] = {}
+    output = result.stdout
+    offset = 0
+    for expected in object_ids:
+        newline = output.find(b"\n", offset)
+        if newline < 0:
+            return {}, "git cat-file returned a truncated header"
+        fields = output[offset:newline].split()
+        if len(fields) != 3 or os.fsdecode(fields[0]) != expected or fields[1] != b"blob":
+            return {}, "git cat-file returned unexpected object metadata"
+        try:
+            size = int(fields[2])
+        except ValueError:
+            return {}, "git cat-file returned an invalid blob size"
+        start = newline + 1
+        end = start + size
+        if end >= len(output) or output[end : end + 1] != b"\n":
+            return {}, "git cat-file returned truncated blob content"
+        blobs[expected] = output[start:end]
+        offset = end + 1
+    if offset != len(output):
+        return {}, "git cat-file returned trailing data"
+    return blobs, None
+
+
+@contextmanager
+def materialize_tree(repo: Path, commit: str) -> Iterator[tuple[Path | None, str | None]]:
+    """Yield tracked tree bytes without checkout filters or archive attributes."""
+    entries, entry_error = _tree_entries(repo, commit)
+    if entry_error:
+        yield None, entry_error
+        return
+    blobs, blob_error = _read_blobs(repo, entries)
+    if blob_error:
+        yield None, blob_error
+        return
+    with TemporaryDirectory(prefix="context-engineering-tree-") as temporary:
+        root = Path(temporary)
+        try:
+            for entry in entries:
+                target = root.joinpath(*PurePosixPath(entry.path).parts)
+                if entry.mode == "160000":
+                    target.mkdir(parents=True, exist_ok=True)
+                    continue
+                target.parent.mkdir(parents=True, exist_ok=True)
+                content = blobs[entry.object_id]
+                if entry.mode == "120000":
+                    link_text = os.fsdecode(content)
+                    link = PurePosixPath(link_text)
+                    normalized = posixpath.normpath(
+                        str(PurePosixPath(entry.path).parent / link)
+                    )
+                    if link.is_absolute() or normalized == ".." or normalized.startswith("../"):
+                        raise OSError(f"tracked symlink escapes the Git tree: {entry.path!r}")
+                    target.symlink_to(link_text)
+                    continue
+                target.write_bytes(content)
+                if entry.mode == "100755":
+                    target.chmod(target.stat().st_mode | stat.S_IXUSR)
+        except OSError as exc:
+            yield None, f"could not materialize Git tree: {exc}"
+            return
+        yield root, None

context_engineering/infra/markdown.py

@@ -0,0 +1,58 @@
+"""Shared Markdown visibility helpers for deterministic context checks."""
+
+from __future__ import annotations
+
+import re
+
+_HTML_COMMENT_RE = re.compile(r"<!--.*?(?:-->|$)", re.DOTALL)
+
+
+def _masked_line(line: str) -> str:
+    return "".join(
+        "\n" if character == "\n" else "\r" if character == "\r" else " " for character in line
+    )
+
+
+def _fence_marker(line: str) -> tuple[str, int] | None:
+    text = line.rstrip("\r\n")
+    indentation = len(text) - len(text.lstrip(" "))
+    if indentation > 3:
+        return None
+    body = text[indentation:]
+    if not body or body[0] not in {"`", "~"}:
+        return None
+    marker = body[0]
+    length = len(body) - len(body.lstrip(marker))
+    return (marker, length) if length >= 3 else None
+
+
+def _closes_fence(line: str, marker: str, minimum_length: int) -> bool:
+    text = line.rstrip("\r\n")
+    indentation = len(text) - len(text.lstrip(" "))
+    if indentation > 3:
+        return False
+    body = text[indentation:]
+    length = len(body) - len(body.lstrip(marker))
+    return length >= minimum_length and not body[length:].strip()
+
+
+def mask_invisible_markdown(content: str) -> str:
+    """Replace fenced blocks and HTML comments while preserving line positions."""
+    visible: list[str] = []
+    marker: str | None = None
+    minimum_length = 0
+    for line in content.splitlines(keepends=True):
+        if marker is not None:
+            visible.append(_masked_line(line))
+            if _closes_fence(line, marker, minimum_length):
+                marker = None
+                minimum_length = 0
+            continue
+        opening = _fence_marker(line)
+        if opening is None:
+            visible.append(line)
+            continue
+        marker, minimum_length = opening
+        visible.append(_masked_line(line))
+    without_fences = "".join(visible)
+    return _HTML_COMMENT_RE.sub(lambda match: _masked_line(match.group(0)), without_fences)

context_engineering/infra/yaml_frontmatter.py

@@ -0,0 +1,70 @@
+"""One frontmatter parser. Replaces the two hand-rolled parsers in the codebase.
+
+We don't pull in PyYAML — the schema is tightly constrained (kebab-cased top-level
+keys, optional scalar values, optional list of inline dicts). This parser handles
+everything the plugin emits and nothing more.
+"""
+
+from __future__ import annotations
+
+import re
+
+_TOP_KEY_RE = re.compile(r"^([a-z][a-z0-9_-]*):\s*(.*)$")
+
+
+def parse_frontmatter(content: str) -> tuple[dict | None, str]:
+    """Return (frontmatter_dict, body). `None` if content has no frontmatter."""
+    if not content.startswith("---"):
+        return None, content
+
+    end = content.find("\n---", 3)
+    if end == -1:
+        return None, content
+
+    raw = content[3:end].strip()
+    body = content[end + 4:].lstrip("\n")
+
+    fm: dict = {}
+    current_key: str | None = None
+    current_list: list | None = None
+
+    for line in raw.splitlines():
+        if not line.strip() or line.strip().startswith("#"):
+            continue
+
+        top = _TOP_KEY_RE.match(line) if not line.startswith(" ") else None
+        if top:
+            if current_key is not None and current_list is not None:
+                fm[current_key] = current_list
+                current_list = None
+
+            key, value = top.group(1), top.group(2).strip()
+            if value == "":
+                current_key = key
+                current_list = None
+            elif value == "[]":
+                fm[key] = []
+                current_key = key
+                current_list = None
+            else:
+                fm[key] = value
+                current_key = key
+                current_list = None
+            continue
+
+        stripped = line.strip()
+        if stripped.startswith("- ") and current_key is not None:
+            item = stripped[2:].strip()
+            if current_list is None:
+                current_list = []
+            if ":" in item and item.split(":", 1)[0].strip().isidentifier():
+                # Inline dict entry like `- id: foo`
+                k, _, v = item.partition(":")
+                current_list.append({k.strip(): v.strip()})
+            else:
+                current_list.append(item)
+
+    if current_key is not None and current_list is not None:
+        fm[current_key] = current_list
+
+    return fm, body

context_engineering_cli-2.6.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.5
+Name: context-engineering-cli
+Version: 2.6.0
+Summary: Portable CLI for Context Engineering analyzers.
+License: MIT License
+        
+        Copyright (c) 2026 safurrier
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.11

context_engineering_cli-2.6.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+context_engineering/__init__.py,sha256=3mgr87eJEJl9yhhFAzNPn6xHcy7EOov6KBuab6x3nU4,76
+context_engineering/__main__.py,sha256=fi_tkPTbyCAM_UhTg1qcz10jmie3vNrg50QOOU4mX-s,75
+context_engineering/analysis/__init__.py,sha256=1Sii4fbwxLJukSHqDYihcLV5fErPI6kRJumpa_rplNg,64
+context_engineering/analysis/backfill.py,sha256=T7elnNsy7aeWpUPXAaQF5XRhh321tcZLv1sc8DczMDg,39108
+context_engineering/analysis/context_check.py,sha256=lsjgMwyLUALlFc36T6Hsuwt3pND7fjEP8lbEbyuiSDo,9979
+context_engineering/analysis/context_layout.py,sha256=MwZNgiEIUdhB9v92eyjskqMWYsCf2Y2i6zjf0027tco,3790
+context_engineering/analysis/context_review.py,sha256=KFJG900geWdvovTpP28Y9JWYXMVi9XIRHsKvicA76zY,7501
+context_engineering/analysis/impact.py,sha256=5f1_QCRdCklbVwQC1r3NlWJXXNPRp1twGPN1CdEgrhM,2736
+context_engineering/analysis/sessions.py,sha256=NCjqN-xOY4dhktglcIQpxSWVoRFCHE_lVZEntCyNgWk,1439
+context_engineering/analysis/staleness.py,sha256=HC3IVRlyu7e-S7vn3DzewFb8RWNpfZ8eyXQi36as85k,6153
+context_engineering/analysis/tier.py,sha256=91ORWsJ_laQxUPI9JfQfBi0ygI31Jx7kRfX0LFCfU3g,2687
+context_engineering/analysis/cross_cutting/__init__.py,sha256=RcDjy89T0zU2W-iI7fi1TJYf2pQOD_0Oo9BHlccMuMk,162
+context_engineering/analysis/cross_cutting/authors.py,sha256=bYT1d1yZKT0qqM8d20_KC0lMlUOJkfT0igVovuv8mtk,1930
+context_engineering/analysis/cross_cutting/buckets.py,sha256=3aqn-g0jK1MpejOfqE13cGwezOc5YEhBEwgg_qwJTYM,1354
+context_engineering/analysis/cross_cutting/co_change.py,sha256=7tovGwRvI1I5mzuEXFWkEgLaCYeu9nDDqwAakbMr_gY,1591
+context_engineering/analysis/cross_cutting/discover.py,sha256=uzNflqhI_8H__V7PLKlZFTB_ONm9VNZ41EK5_LIEVFQ,2507
+context_engineering/analysis/cross_cutting/imports.py,sha256=kkZ8-uKqtTHbl1igS2kEe3eOeYWnyxqyNVVBZlOTCOU,2026
+context_engineering/analysis/cross_cutting/pair.py,sha256=B91LFQ04EeTuffdtk8Kbfg4JalKsGNTXhEZZmkiElWg,4215
+context_engineering/checks/__init__.py,sha256=G1oNPg6aUrqf9P70T7sBIC6W3xdWwJD8bJ5hXSO4Xcg,51
+context_engineering/checks/contracts.py,sha256=B6EEWfZcAwAoHeolRiBjdOPebJqKmL_OB6VC5WWJgaQ,15631
+context_engineering/checks/depth.py,sha256=sFY-42FvnvgunEwGgNRtQIca_MzgF1W3-cSu8V6-dyc,2963
+context_engineering/checks/frontmatter.py,sha256=s1V5w75i7GwyZhLU7zladXdp_V804o3Z1Po38SBAFmU,4436
+context_engineering/checks/references.py,sha256=28ZyXwHgCxxKC3BKDwbbo9QaYS98T9_UgJ6KrR7V44k,11370
+context_engineering/checks/skill_structure.py,sha256=Tw97b3TnPQPNX_Wg91VvS8lkAeW97ianhEhwH7wKbQA,4513
+context_engineering/checks/antipatterns/__init__.py,sha256=46H9dq5qr8T6sgDWY7V8r2Ayg2Gx_QoDXS_bGrgOow0,117
+context_engineering/checks/antipatterns/context.py,sha256=_QklypUB9PJU0E86UC6GZnSCU_DJ03lzm9WZtMg4DeQ,675
+context_engineering/checks/antipatterns/density.py,sha256=D9-zIoJUsReHPPV6DEB3CI3WeWf13vnolOpUNLESl1s,2206
+context_engineering/checks/antipatterns/line_limits.py,sha256=WvH-H59NK6-XQ3xHaSCRbmrUpfYx2claOLsFQH4SzXk,1858
+context_engineering/checks/antipatterns/runner.py,sha256=tY08CKqQ7d94RGI1d1i0XrQ4AnFdd6FRpiSKWmWBvqU,4206
+context_engineering/checks/antipatterns/splitting.py,sha256=QJzV5Ut9dNP-RAHG4eT8wj6hItm1hlRFj6XrdqvowTs,3181
+context_engineering/checks/antipatterns/volatile.py,sha256=8DLC591-dqf64FA-irI7QOA2c5IEwW0ANU60vWlu27w,1343
+context_engineering/checks/antipatterns/watermark.py,sha256=fl4ESKBv8PPHNLM76ETDJydszTHgGhEK4oGQVwaJMl4,3753
+context_engineering/cli/__init__.py,sha256=T8XCbwTmhRg-JFuhIqpiyRw-Dyba0SuaIOjYnzHq_T8,47
+context_engineering/cli/dispatch.py,sha256=zParI8G6_QOHyk2baB0jDGMXGU1MGndaLohQEI9yQKk,3056
+context_engineering/cli/registry.py,sha256=DJyeVcCvpxURW9eWpPKCPBoLxI-S4f3P6nkoWfzrT5U,928
+context_engineering/cli/render.py,sha256=E1fqozVlA5DH8JYuAX5civchezLopjwkMVRDIIuuYys,3122
+context_engineering/cli/subcommands.py,sha256=iIbu7VNnC7DIA3-4_jib-w0vVRAc5paB2ecMsXzvltE,18370
+context_engineering/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+context_engineering/domain/commit.py,sha256=trd7vLJw06Cft_TvUItpKIcRSuVnGiwi1dDd-gD1Krw,514
+context_engineering/domain/evidence.py,sha256=0xTgJJgm8nYZVR6N-l5Dg7xJB49OPH5A1peha-3PtF4,1634
+context_engineering/domain/finding.py,sha256=w80d29bWZkJIfTnfRB_TEsWkeCX3NYSEsPb6Sx3zd-M,905
+context_engineering/domain/result.py,sha256=Gr2Tw2J08Nijr7G1WRhj-NSJc675CV8gEqeHZFO2Pg4,1630
+context_engineering/infra/__init__.py,sha256=CCkGe59MnxiVwY3kdfmRGWiN0UKYEMKJGRi5zmVLsZ0,324
+context_engineering/infra/filesystem.py,sha256=4FXrGLBLmYGSVFdSJQrgrzc9Q8Gat7tglGvLjtZ5PGg,713
+context_engineering/infra/git.py,sha256=xpDgjxflk_dGTiOpoU6IOiMIRbeRqZY5PkQvQ4CWl3M,4920
+context_engineering/infra/git_evidence.py,sha256=aXNY9DuHUtDPVeMA7Nqc5SNYQGWdQ-B5gZ2CTYO0054,11679
+context_engineering/infra/git_tree.py,sha256=-PZQbYsyXIYpJNBpP1Zo-Lt71Fbxl7LJfnppG3cmVwc,5390
+context_engineering/infra/markdown.py,sha256=tHSt66r4PTYYRTUIfwIjSEDCeGFtcNBrn-YtAhgrioY,1923
+context_engineering/infra/yaml_frontmatter.py,sha256=yVZamFli5iCUsvdzV2a8VAq_ETqnlciCxcX_iOEQnMY,2290
+provenance.json,sha256=3elXiJzp__2KjnqNhOFW_9bkvApaF6HRlCI3lQCyYyw,599
+context_engineering_cli-2.6.0.dist-info/METADATA,sha256=EO4WBUvvPudA7_HuqjZU-9rMWwl1MqOBzPjzvByl0do,1405
+context_engineering_cli-2.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+context_engineering_cli-2.6.0.dist-info/entry_points.txt,sha256=PRSEj7vD7_aYqcfeslJIJ0VsWK2bMPh31QifshEsRis,69
+context_engineering_cli-2.6.0.dist-info/licenses/LICENSE,sha256=a_2IOUCuE6IJu-MvjvKkL8hQnGtMybcXi2SAnR65YIY,1066
+context_engineering_cli-2.6.0.dist-info/RECORD,,

context_engineering_cli-2.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

context_engineering_cli-2.6.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+context-engineering = context_engineering.cli:main

context_engineering_cli-2.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 safurrier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

provenance.json

@@ -0,0 +1 @@
+{"schema": 1, "decision": "This package contains the independently authored portable Context Engineering CLI.", "entries": [{"path_prefix": "src/context_engineering/", "origin": "same-author portable implementation", "license": "MIT"}, {"path": "LICENSE", "origin": "standard MIT text", "license": "MIT"}, {"path": ".gitignore", "origin": "shared repository build exclusions", "license": "MIT"}, {"path": "pyproject.toml", "origin": "same-author package build and project metadata", "license": "MIT"}, {"path": "provenance.json", "origin": "package-scoped provenance inventory", "license": "MIT"}]}