embtrace-check 0.1.0__py3-none-any.whl

embtrace_check/__init__.py

@@ -0,0 +1,3 @@
+"""embtrace-check — standalone collector for the embtrace CRA Readiness Check."""
+
+__version__ = "0.1.0"

embtrace_check/analyzer/__init__.py

@@ -0,0 +1 @@
+"""Vendored subset of the embtrace analyzer (deterministic tiers only)."""

embtrace_check/analyzer/models.py

@@ -0,0 +1,148 @@
+"""Pydantic models for AI project analyzer.
+
+Covers LLM analysis output, reconciliation results, and the decisions.yaml
+persistence format.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+# ---------------------------------------------------------------------------
+# LLM output models
+# ---------------------------------------------------------------------------
+
+class BuildFileDependency(BaseModel):
+    """A dependency detected by LLM analysis of build files."""
+
+    name: str
+    version: str = ""
+    ecosystem: str = ""
+    source_file: str = ""
+    source_line: int = 0
+    context: str = ""          # LLM context, e.g. "inside if(USE_LIBRESSL)"
+    confidence: float = 1.0
+    tier: int = 0              # 0=LLM, 1-5=Pipeline tier
+    detection_method: str = "" # e.g. "cargo-metadata", "regex-cmake", "treesitter-meson"
+
+
+class BuildFileArtifact(BaseModel):
+    """An artifact (binary, library, etc.) detected in build files."""
+
+    path: str
+    artifact_type: str = "binary"  # binary | library | config | script
+    source_file: str = ""
+    source_line: int = 0
+
+
+class BuildFileInternalDep(BaseModel):
+    """An internal project dependency detected in build files."""
+
+    project: str
+    source_file: str = ""
+    source_line: int = 0
+    context: str = ""
+
+
+class LLMAnalysisResult(BaseModel):
+    """Result of analyzing a single build file with the LLM."""
+
+    file_path: str
+    dependencies: list[BuildFileDependency] = []
+    artifacts: list[BuildFileArtifact] = []
+    internal_deps: list[BuildFileInternalDep] = []
+
+
+# ---------------------------------------------------------------------------
+# Reconciliation result models
+# ---------------------------------------------------------------------------
+
+class ConfirmedEntry(BaseModel):
+    """Both lockfile scanner and build-file analysis agree on this dependency."""
+
+    name: str
+    version: str
+    ecosystem: str = ""
+    source_file: str = ""
+
+
+class LockfileOnlyEntry(BaseModel):
+    """Dependency found only in the lockfile scanner output."""
+
+    name: str
+    version: str
+    ecosystem: str = ""
+    accept: bool | None = None
+
+
+class BuildFileOnlyEntry(BaseModel):
+    """Dependency found only in LLM build-file analysis."""
+
+    name: str
+    version: str = ""
+    ecosystem: str = ""
+    source_file: str = ""
+    confidence: float = 1.0
+    context: str = ""
+    accept: bool | None = None
+
+
+class ConflictEntry(BaseModel):
+    """Version mismatch between lockfile and build-file analysis."""
+
+    name: str
+    lockfile_version: str
+    build_file_version: str
+    ecosystem: str = ""
+    source_file: str = ""
+    accept: bool | None = None
+    use_version: str = ""
+
+
+class ArtifactEntry(BaseModel):
+    """A produced artifact detected in build files."""
+
+    path: str
+    artifact_type: str = "binary"
+    source_file: str = ""
+
+
+class InternalDepEntry(BaseModel):
+    """An internal dependency detected in build files."""
+
+    project: str
+    source_file: str = ""
+    context: str = ""
+    accept: bool | None = None
+
+
+# ---------------------------------------------------------------------------
+# decisions.yaml root model
+# ---------------------------------------------------------------------------
+
+class DecisionsFile(BaseModel):
+    """Root model for .embtrace/proposal/decisions.yaml."""
+
+    scan_date: str
+    model: str = ""
+    confirmed: list[ConfirmedEntry] = []
+    lockfile_only: list[LockfileOnlyEntry] = []
+    build_file_only: list[BuildFileOnlyEntry] = []
+    conflicts: list[ConflictEntry] = []
+    artifacts: list[ArtifactEntry] = []
+    internal_dependencies: list[InternalDepEntry] = []
+
+
+# ---------------------------------------------------------------------------
+# Reconciliation container
+# ---------------------------------------------------------------------------
+
+class ReconciliationResult(BaseModel):
+    """Container for reconciliation output — input to proposal generation."""
+
+    confirmed: list[ConfirmedEntry] = []
+    lockfile_only: list[LockfileOnlyEntry] = []
+    build_file_only: list[BuildFileOnlyEntry] = []
+    conflicts: list[ConflictEntry] = []
+    artifacts: list[ArtifactEntry] = []
+    internal_dependencies: list[InternalDepEntry] = []

embtrace_check/analyzer/normalize.py

@@ -0,0 +1,118 @@
+"""Shared dependency name normalization.
+
+Consolidated from reconciler._normalize_name() and eval.normalize_dep_name()
+to provide a single source of truth for name matching across the analyzer.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Version suffix pattern: _0_3, _1_0, _2, _3_0, _2_11, etc.
+# Applied AFTER separator normalization (- → _), so dots become _.
+_VERSION_SUFFIX = re.compile(r"(?:_\d+)+$")
+
+# Component suffixes commonly appended to pkg-config names
+_COMPONENT_SUFFIXES = (
+    "_client", "_server", "_base", "_core", "_common",
+    "_egl", "_cursor", "_protocols", "_generic",
+    "_video", "_app", "_riff", "_pbutils", "_audio",
+    "_simple", "_allocators",
+)
+
+# CMake Find-module names often differ from pkg-config / canonical names.
+# Map normalized aliases → canonical normalized name.
+_ALIASES: dict[str, str] = {
+    # pkg-config → canonical
+    "cares": "c_ares",
+    "pulse": "pulseaudio",
+    "pulse_simple": "pulseaudio",
+    "avcodec": "ffmpeg",
+    "avformat": "ffmpeg",
+    "avutil": "ffmpeg",
+    "swscale": "ffmpeg",
+    "swresample": "ffmpeg",
+    "avdevice": "ffmpeg",
+    "avfilter": "ffmpeg",
+    "postproc": "ffmpeg",
+    "gtk2": "gtk",
+    "gtk3": "gtk",
+    "gtk4": "gtk",
+    "gtk_3": "gtk",
+    "gstreamer": "gstreamer",
+    "gstreamer_base": "gstreamer",
+    "gstreamer_video": "gstreamer",
+    "gstreamer_app": "gstreamer",
+    "gstreamer_riff": "gstreamer",
+    "gstreamer_pbutils": "gstreamer",
+    # CMake module variants
+    "dbus1": "dbus",
+    "dbus_1": "dbus",
+    "sdl2": "sdl",
+    "sdl3": "sdl",
+    "qt6widgets": "qt",
+    "qt5widgets": "qt",
+    "qt6core": "qt",
+    "qt5core": "qt",
+    "qt6gui": "qt",
+    "qt5gui": "qt",
+    "qt6": "qt",
+    "qt5": "qt",
+    "gtest": "googletest",
+    "gmock": "googletest",
+    "pythoninterp": "python",
+    "pythonlibs": "python",
+    "python3": "python",
+    "cudnn": "cudnn",
+    "cudatoolkit": "cuda",
+    "threads": "pthread",
+    "pthreads": "pthread",
+    # -l flag names → package names
+    "ssl": "openssl",
+    "crypto": "openssl",
+    "z": "zlib",
+    # OpenCV-specific
+    "onnxruntime": "onnx_runtime",
+    # Wayland components
+    "wayland_scanner": "wayland",
+    # glib variants (with and without version suffix)
+    "glib_2": "glib",
+    "gobject_2": "glib",
+    "gobject": "glib",
+    "gmodule": "glib",
+    "gmodule_2": "glib",
+    "gio_2": "glib",
+    "gio": "glib",
+    # mesa / graphics
+    "glslangvalidator": "glslang",
+    "sensors": "lmsensors",
+}
+
+
+def normalize_dep_name(name: str) -> str:
+    """Normalize a dependency name for matching.
+
+    Lowercases, strips common prefixes (lib, python-, py-),
+    strips version suffixes and component suffixes from pkg-config names,
+    normalizes separators (-, ., +, space → _), and applies alias mappings.
+    """
+    n = name.lower().strip()
+    # Strip common prefixes
+    for prefix in ("lib", "python-", "py-"):
+        if n.startswith(prefix) and len(n) > len(prefix) + 1:
+            n = n[len(prefix):]
+            break
+    # Remove + (gtk+ → gtk)
+    n = n.replace("+", "")
+    # Normalize separators
+    n = n.replace("-", "_").replace(".", "_").replace(" ", "_")
+    # Strip version suffixes (e.g. pipewire_0_3 → pipewire)
+    n = _VERSION_SUFFIX.sub("", n)
+    # Strip component suffixes (e.g. wayland_client → wayland)
+    for suffix in _COMPONENT_SUFFIXES:
+        if n.endswith(suffix) and len(n) > len(suffix):
+            n = n[: -len(suffix)]
+            break
+    # Apply alias mappings
+    n = _ALIASES.get(n, n)
+    return n

embtrace_check/analyzer/parsers/__init__.py

@@ -0,0 +1,40 @@
+"""Deterministic build-file parsers.
+
+Each parser module exposes a ``parse(content: str) -> list[str]`` function
+that extracts dependency names from a specific build-file format.
+
+The ``PARSERS`` dict maps file_type → parse function, matching the types
+used by ``scanner.BUILD_FILE_PATTERNS``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from embtrace_check.analyzer.parsers.autotools import parse as parse_autotools
+from embtrace_check.analyzer.parsers.cargo import parse as parse_cargo
+from embtrace_check.analyzer.parsers.cmake import parse as parse_cmake
+from embtrace_check.analyzer.parsers.configure import parse as parse_configure
+from embtrace_check.analyzer.parsers.gomod import parse as parse_go
+from embtrace_check.analyzer.parsers.gradle import parse as parse_gradle
+from embtrace_check.analyzer.parsers.makefile import parse as parse_make
+from embtrace_check.analyzer.parsers.maven import parse as parse_maven
+from embtrace_check.analyzer.parsers.meson import parse as parse_meson
+from embtrace_check.analyzer.parsers.npm import parse as parse_npm
+from embtrace_check.analyzer.parsers.python import parse as parse_python
+
+# Maps file_type (from scanner.BUILD_FILE_PATTERNS) → parser function
+PARSERS: dict[str, Callable[[str], list[str]]] = {
+    "cmake": parse_cmake,
+    "meson": parse_meson,
+    "cargo": parse_cargo,
+    "go": parse_go,
+    "python": parse_python,
+    "npm": parse_npm,
+    "gradle": parse_gradle,
+    "maven": parse_maven,
+    "autotools": parse_autotools,
+    "configure": parse_configure,
+    "make": parse_make,
+    "conan": parse_cmake,  # conanfile.py/txt handled separately; fallback to cmake
+}

embtrace_check/analyzer/parsers/autotools.py

@@ -0,0 +1,101 @@
+"""Deterministic Autotools parser (configure.ac / configure.in).
+
+Extracts dependency names from GNU Autotools build files:
+- AC_CHECK_LIB([name], [func])
+- AC_CHECK_HEADER([header.h])
+- PKG_CHECK_MODULES([VAR], [name >= version])
+- AC_SEARCH_LIBS([func], [lib1 lib2 ...])
+- AX_CHECK_OPENSSL / AX_CHECK_ZLIB etc.
+"""
+
+from __future__ import annotations
+
+import re
+
+# AC_CHECK_LIB([crypto], [SHA1_Init], ...)
+# AC_CHECK_LIB(curl, curl_global_init, ...)
+_AC_CHECK_LIB = re.compile(
+    r"AC_CHECK_LIB\s*\(\s*\[?(\w+)\]?",
+    re.IGNORECASE,
+)
+
+# PKG_CHECK_MODULES([DLT], ['automotive-dlt >= 2.11'])
+# PKG_CHECK_MODULES(DLT, automotive-dlt >= 2.11)
+_PKG_CHECK_MODULES = re.compile(
+    r"PKG_CHECK_MODULES\s*\(\s*\[?\w+\]?\s*,\s*\[?'?\"?([a-zA-Z0-9_][a-zA-Z0-9_.+-]*)",
+)
+
+# AC_SEARCH_LIBS([clock_gettime], [rt posix4])
+# Also handles unbracketed: AC_SEARCH_LIBS(fmod, m)
+_AC_SEARCH_LIBS = re.compile(
+    r"AC_SEARCH_LIBS\s*\(\s*\[?\w+\]?\s*,\s*\[?([^\],\)]+)",
+)
+
+# AC_CHECK_HEADER([header.h]) — not always a dependency, but useful
+_AC_CHECK_HEADER = re.compile(
+    r"AC_CHECK_HEADER\s*\(\s*\[?([a-zA-Z0-9_/.+-]+\.h)\]?",
+)
+
+# AX_CHECK_OPENSSL, AX_CHECK_ZLIB, etc.
+_AX_CHECK = re.compile(
+    r"AX_CHECK_(\w+)",
+)
+
+# Header → library name mapping (common cases)
+_HEADER_TO_LIB: dict[str, str] = {
+    "openssl/ssl.h": "openssl",
+    "openssl/crypto.h": "openssl",
+    "curl/curl.h": "libcurl",
+    "zlib.h": "zlib",
+    "expat.h": "libexpat",
+    "pcre2.h": "libpcre2",
+    "pcre.h": "libpcre",
+    "iconv.h": "libiconv",
+    "libintl.h": "libintl",
+    "pthread.h": "pthread",
+}
+
+
+def _strip_comments(content: str) -> str:
+    """Remove autotools comments (dnl ... and # ...)."""
+    content = re.sub(r"dnl\s+[^\n]*", "", content)
+    content = re.sub(r"#[^\n]*", "", content)
+    return content
+
+
+def parse(content: str) -> list[str]:
+    """Extract dependency names from configure.ac content."""
+    content = _strip_comments(content)
+    deps: set[str] = set()
+
+    # AC_CHECK_LIB
+    for m in _AC_CHECK_LIB.finditer(content):
+        name = m.group(1)
+        # Prefix with lib if it's a short name (convention)
+        if len(name) > 1:
+            deps.add(name)
+
+    # PKG_CHECK_MODULES
+    for m in _PKG_CHECK_MODULES.finditer(content):
+        deps.add(m.group(1))
+
+    # AC_SEARCH_LIBS — extract each library name
+    for m in _AC_SEARCH_LIBS.finditer(content):
+        libs = m.group(1).split()
+        for lib in libs:
+            lib = lib.strip()
+            if lib:
+                deps.add(lib)
+
+    # AX_CHECK_*
+    for m in _AX_CHECK.finditer(content):
+        name = m.group(1).lower()
+        deps.add(name)
+
+    # AC_CHECK_HEADER — map known headers to library names
+    for m in _AC_CHECK_HEADER.finditer(content):
+        header = m.group(1)
+        if header in _HEADER_TO_LIB:
+            deps.add(_HEADER_TO_LIB[header])
+
+    return sorted(deps)

embtrace_check/analyzer/parsers/cargo.py

@@ -0,0 +1,102 @@
+"""Deterministic Cargo.toml parser.
+
+Extracts dependency names from Rust Cargo.toml by parsing:
+- [dependencies]
+- [dev-dependencies]
+- [build-dependencies]
+- [target.'cfg(...)'.dependencies]
+
+Filters out path-only dependencies (workspace members).
+"""
+
+from __future__ import annotations
+
+import re
+
+# Section headers
+_SECTION = re.compile(r"^\[([^\]]+)\]", re.MULTILINE)
+
+# Simple dependency: name = "version"
+_SIMPLE_DEP = re.compile(r"^(\w[\w-]*)\s*=\s*\"([^\"]+)\"", re.MULTILINE)
+
+# Table dependency: name = { version = "...", ... }
+# Also matches: name = { path = "..." } (internal — filter later)
+_TABLE_DEP = re.compile(
+    r"^(\w[\w-]*)\s*=\s*\{([^}]+)\}",
+    re.MULTILINE,
+)
+
+# Workspace members in [workspace]
+_WORKSPACE_MEMBERS = re.compile(
+    r"members\s*=\s*\[([^\]]+)\]",
+    re.DOTALL,
+)
+
+
+def _is_dep_section(section: str) -> bool:
+    """Check if a TOML section header is a dependency section."""
+    s = section.lower().strip()
+    return s.endswith("dependencies") and not s.startswith("workspace")
+
+
+_PACKAGE_FIELD = re.compile(r'package\s*=\s*"([^"]+)"')
+
+
+def _extract_package_name(table_content: str) -> str | None:
+    """Extract the actual package name from a ``package = "..."`` field."""
+    m = _PACKAGE_FIELD.search(table_content)
+    return m.group(1) if m else None
+
+
+def _has_path_only(table_content: str) -> bool:
+    """Check if a table-style dependency is path-only (internal)."""
+    has_path = "path" in table_content
+    has_version = "version" in table_content
+    has_git = "git" in table_content
+    has_workspace = re.search(r"workspace\s*=\s*true", table_content) is not None
+    # workspace = true without external source = workspace/internal dep
+    if has_workspace and not has_git:
+        return True
+    # path-only without version = workspace/internal dep
+    return has_path and not has_version and not has_git
+
+
+def parse(content: str) -> list[str]:
+    """Extract dependency names from Cargo.toml content."""
+    deps: set[str] = set()
+
+    # Find all sections and their content ranges
+    sections: list[tuple[str, int, int]] = []
+    for m in _SECTION.finditer(content):
+        sections.append((m.group(1), m.end(), 0))  # end will be filled below
+
+    # Fill section end positions
+    filled: list[tuple[str, int, int]] = []
+    for i, (name, start, _) in enumerate(sections):
+        end = (
+            sections[i + 1][1] - len(sections[i + 1][0]) - 2
+            if i + 1 < len(sections) else len(content)
+        )
+        filled.append((name, start, end))
+
+    # Process each dependency section
+    for section_name, start, end in filled:
+        if not _is_dep_section(section_name):
+            continue
+
+        section_content = content[start:end]
+
+        # Simple deps: name = "version"
+        for m in _SIMPLE_DEP.finditer(section_content):
+            deps.add(m.group(1))
+
+        # Table deps: name = { version = "...", ... }
+        for m in _TABLE_DEP.finditer(section_content):
+            name = m.group(1)
+            table = m.group(2)
+            if not _has_path_only(table):
+                # Use actual package name if renamed (package = "real_name")
+                pkg = _extract_package_name(table)
+                deps.add(pkg if pkg else name)
+
+    return sorted(deps)