component-mapper 0.1.0__py3-none-any.whl

component_mapper/utils/similarity.py

@@ -0,0 +1,69 @@
+from difflib import SequenceMatcher
+from component_mapper.models import RankedCandidate
+
+
+def jaccard_similarity(set_a: set, set_b: set) -> float:
+    """Intersection over union. Returns 1.0 if both sets are empty."""
+    if not set_a and not set_b:
+        return 1.0
+    union = set_a | set_b
+    if not union:
+        return 0.0
+    return len(set_a & set_b) / len(union)
+
+
+def skeleton_similarity(skeleton_a: str, skeleton_b: str) -> float:
+    """Normalized edit distance on skeleton strings using SequenceMatcher."""
+    if not skeleton_a and not skeleton_b:
+        return 1.0
+    if not skeleton_a or not skeleton_b:
+        return 0.0
+    return SequenceMatcher(None, skeleton_a, skeleton_b).ratio()
+
+
+def composite_score(
+    structural: float,
+    class_tokens: float,
+    type_compat: float,
+    weights: tuple[float, float, float] = (0.5, 0.3, 0.2),
+) -> float:
+    """Weighted sum of structural, class_tokens, type_compat scores."""
+    w_s, w_c, w_t = weights
+    result = w_s * structural + w_c * class_tokens + w_t * type_compat
+    return max(0.0, min(1.0, result))
+
+
+def tfidf_cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
+    """Cosine similarity between two TF-IDF vectors."""
+    if not vec_a or not vec_b:
+        return 0.0
+
+    try:
+        import numpy as np
+
+        a = np.array(vec_a, dtype=float)
+        b = np.array(vec_b, dtype=float)
+        norm_a = np.linalg.norm(a)
+        norm_b = np.linalg.norm(b)
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+        return float(np.dot(a, b) / (norm_a * norm_b))
+    except ImportError:
+        # Pure Python fallback
+        dot = sum(x * y for x, y in zip(vec_a, vec_b))
+        norm_a = sum(x * x for x in vec_a) ** 0.5
+        norm_b = sum(y * y for y in vec_b) ** 0.5
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+        return dot / (norm_a * norm_b)
+
+
+def rank_candidates(
+    candidates: list[RankedCandidate],
+    top_k: int = 4,
+    min_threshold: float = 0.40,
+) -> list[RankedCandidate]:
+    """Sort by composite_score descending, filter below threshold, return top_k."""
+    filtered = [c for c in candidates if c.composite_score >= min_threshold]
+    filtered.sort(key=lambda c: c.composite_score, reverse=True)
+    return filtered[:top_k]

component_mapper/utils/source_parser.py

@@ -0,0 +1,292 @@
+import re
+from dataclasses import dataclass, field
+from component_mapper.models import PropDefinition, InteractivityMode
+
+
+STRUCTURAL_CLASS_PATTERN = re.compile(
+    r"\b(card|grid|list|item|hero|nav|menu|header|footer|sidebar|"
+    r"form|modal|badge|price|rating|carousel|pagination|search|"
+    r"feature|testimonial|cta|faq|pricing|article|media|table|"
+    r"product|blog|news|collection|section|widget)\b",
+    re.IGNORECASE,
+)
+
+PROPS_INTERFACE_PATTERN = re.compile(
+    r"(?:interface\s+\w*Props\w*|type\s+\w*Props\w*\s*=)\s*\{([^}]+)\}", re.DOTALL
+)
+INTERACTIVE_HOOKS_PATTERN = re.compile(
+    r"\b(useState|useEffect|onClick|onChange|useRef|useCallback|useReducer)\b"
+)
+PARTIAL_INTERACTIVE_PATTERN = re.compile(r"\b(onMouseEnter|onFocus|onBlur|onHover)\b")
+RETURN_BLOCK_PATTERN = re.compile(r"\breturn\s*\((.*?)\)\s*[;]?\s*\}", re.DOTALL)
+RETURN_BLOCK_ALT_PATTERN = re.compile(
+    r"\breturn\s*(<[A-Za-z].*?)(?=\n\s*\})", re.DOTALL
+)
+CONDITIONAL_COMPONENT_PATTERN = re.compile(r"\{[^}]*&&\s*<([A-Z][A-Za-z0-9]*)")
+TERNARY_COMPONENT_PATTERN = re.compile(r"\?[^:]*<([A-Z][A-Za-z0-9]*)[^:]*:")
+CLASSNAME_PATTERN = re.compile(r'className=["\']([^"\']+)["\']')
+
+
+@dataclass
+class ParsedSource:
+    dom_skeleton: str = ""
+    root_element: str = "div"
+    required_children: list[str] = field(default_factory=list)
+    optional_children: list[str] = field(default_factory=list)
+    structural_class_tokens: list[str] = field(default_factory=list)
+    typical_nesting_depth: int = 0
+    child_tag_counts: dict[str, int] = field(default_factory=dict)
+    interactivity: InteractivityMode = InteractivityMode.STATIC
+    props: list[PropDefinition] = field(default_factory=list)
+
+
+def parse_source(source_code: str) -> ParsedSource:
+    """Parse TypeScript/TSX source into ParsedSource. Gracefully handles malformed input."""
+    result = ParsedSource()
+    try:
+        jsx_block = _extract_return_block(source_code)
+        if jsx_block:
+            result.dom_skeleton = _parse_jsx_skeleton(jsx_block, max_depth=5)
+            result.root_element = _extract_root_element(jsx_block)
+            result.typical_nesting_depth = _measure_nesting_depth(jsx_block)
+            result.child_tag_counts = _count_child_tags(jsx_block)
+            result.required_children, result.optional_children = _extract_children(
+                jsx_block
+            )
+
+        all_classnames = CLASSNAME_PATTERN.findall(source_code)
+        tokens = set()
+        for cls_string in all_classnames:
+            for token in STRUCTURAL_CLASS_PATTERN.findall(cls_string):
+                tokens.add(token.lower())
+        result.structural_class_tokens = sorted(tokens)
+
+        result.interactivity = _detect_interactivity(source_code)
+        result.props = _extract_props(source_code)
+    except Exception:
+        pass
+    return result
+
+
+def _extract_return_block(source: str) -> str:
+    """Extract the JSX return() block from a component function."""
+    m = RETURN_BLOCK_PATTERN.search(source)
+    if m:
+        return m.group(1).strip()
+    m = RETURN_BLOCK_ALT_PATTERN.search(source)
+    if m:
+        return m.group(1).strip()
+    # Fallback: find any JSX-looking block
+    jsx_start = re.search(r"<[A-Z][A-Za-z]*|<[a-z]+[\s>/]", source)
+    if jsx_start:
+        return source[jsx_start.start() :]
+    return ""
+
+
+def _extract_root_element(jsx_block: str) -> str:
+    """Extract outermost JSX element tag name."""
+    m = re.match(r"<([A-Za-z][A-Za-z0-9]*)", jsx_block.strip())
+    if m:
+        return m.group(1).lower()
+    return "div"
+
+
+def _parse_jsx_skeleton(jsx: str, max_depth: int) -> str:
+    """Recursively parse JSX into skeleton string."""
+    # Build token stream
+    tokens = []
+    for m in re.finditer(r"<(/?)([A-Za-z][A-Za-z0-9]*)([^>]*)(/?)>", jsx):
+        is_close = m.group(1) == "/"
+        tag = m.group(2)
+        # attrs = m.group(3) - Unused
+
+        is_self_close = m.group(4) == "/" or tag.lower() in (
+            "input",
+            "img",
+            "br",
+            "hr",
+            "meta",
+            "link",
+        )
+
+        if is_close:
+            tokens.append(("close", tag, m.start()))
+        elif is_self_close:
+            tokens.append(("self", tag, m.start()))
+        else:
+            tokens.append(("open", tag, m.start()))
+
+    if not tokens:
+        return ""
+
+    def build_tree(pos: int, depth: int) -> tuple[str, int]:
+        if pos >= len(tokens) or depth > max_depth:
+            return "", pos
+
+        kind, tag, _ = tokens[pos]
+        tag_lower = tag.lower()
+
+        if kind == "close":
+            return "", pos
+
+        if kind == "self":
+            return tag_lower, pos + 1
+
+        # kind == 'open'
+        children = []
+        i = pos + 1
+        while i < len(tokens):
+            k, t, _ = tokens[i]
+            if k == "close" and t.lower() == tag_lower:
+                i += 1
+                break
+            child_str, i = build_tree(i, depth + 1)
+            if child_str:
+                children.append(child_str)
+
+        if not children:
+            return tag_lower, i
+        elif len(children) == 1:
+            return f"{tag_lower}>{children[0]}", i
+        else:
+            return f"{tag_lower}>[{'+'.join(children)}]", i
+
+    result, _ = build_tree(0, 0)
+    return result
+
+
+def _measure_nesting_depth(jsx: str) -> int:
+    """Count max nesting depth of JSX tags."""
+    depth = 0
+    max_depth = 0
+    for m in re.finditer(r"<(/?)([A-Za-z][A-Za-z0-9]*)([^>]*)(/?)>", jsx):
+        is_close = m.group(1) == "/"
+        is_self = m.group(4) == "/" or m.group(2).lower() in (
+            "input",
+            "img",
+            "br",
+            "hr",
+        )
+        if is_close:
+            depth = max(0, depth - 1)
+        elif not is_self:
+            depth += 1
+            max_depth = max(max_depth, depth)
+    return max_depth
+
+
+def _count_child_tags(jsx: str) -> dict[str, int]:
+    """Count occurrences of each lowercase HTML tag."""
+    counts: dict[str, int] = {}
+    html_tags = {
+        "div",
+        "span",
+        "p",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "a",
+        "img",
+        "button",
+        "input",
+        "form",
+        "ul",
+        "ol",
+        "li",
+        "table",
+        "tr",
+        "td",
+        "th",
+        "section",
+        "article",
+        "nav",
+        "header",
+        "footer",
+        "main",
+        "aside",
+        "figure",
+        "figcaption",
+        "label",
+        "select",
+        "textarea",
+        "picture",
+        "source",
+    }
+    for m in re.finditer(r"<([A-Za-z][A-Za-z0-9]*)", jsx):
+        tag = m.group(1).lower()
+        if tag in html_tags:
+            counts[tag] = counts.get(tag, 0) + 1
+    return counts
+
+
+def _extract_children(jsx: str) -> tuple[list[str], list[str]]:
+    """Extract required and optional sub-component children."""
+    # All capitalized component refs
+    all_components = set(re.findall(r"<([A-Z][A-Za-z0-9]+)", jsx))
+
+    # Optional: inside conditional expressions
+    optional_set = set()
+    for m in CONDITIONAL_COMPONENT_PATTERN.finditer(jsx):
+        optional_set.add(m.group(1))
+    for m in TERNARY_COMPONENT_PATTERN.finditer(jsx):
+        optional_set.add(m.group(1))
+
+    required = sorted(all_components - optional_set)
+    optional = sorted(optional_set & all_components)
+    return required, optional
+
+
+def _extract_props(source: str) -> list[PropDefinition]:
+    """Parse Props interface/type into PropDefinition list."""
+    m = PROPS_INTERFACE_PATTERN.search(source)
+    if not m:
+        return []
+
+    body = m.group(1)
+    props = []
+
+    # Split on both newlines and semicolons to handle single-line interfaces
+    raw_fields = re.split(r"[;\n]", body)
+    for raw_field in raw_fields:
+        raw_field = raw_field.strip()
+        if not raw_field or raw_field.startswith("//") or raw_field.startswith("*"):
+            continue
+
+        # Match: propName?: Type  or  propName: Type
+        pm = re.match(r"(\w+)(\?)?\s*:\s*(.+?)(?:,)?\s*$", raw_field)
+        if not pm:
+            continue
+
+        name = pm.group(1)
+        optional = pm.group(2) == "?"
+        type_str = pm.group(3).strip().rstrip(",")
+
+        # Extract default from JSDoc or inline comment
+        default_val = None
+        default_m = re.search(r"@default\s+(\S+)", raw_field)
+        if default_m:
+            default_val = default_m.group(1)
+
+        props.append(
+            PropDefinition(
+                name=name,
+                type=type_str,
+                required=not optional,
+                default_value=default_val,
+                description="",
+            )
+        )
+
+    return props
+
+
+def _detect_interactivity(source: str) -> InteractivityMode:
+    """Check for React hooks/event handlers to determine interactivity."""
+    if INTERACTIVE_HOOKS_PATTERN.search(source):
+        return InteractivityMode.INTERACTIVE
+    if PARTIAL_INTERACTIVE_PATTERN.search(source):
+        return InteractivityMode.PARTIAL
+    return InteractivityMode.STATIC

component_mapper-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: component-mapper
+Version: 0.1.0
+Summary: Maps ClassifiedSegment objects to Shadcn UI components and Astro wrappers
+Requires-Python: >=3.12
+Requires-Dist: aiofiles>=23.0
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: litellm>=1.40
+Requires-Dist: numpy>=1.26
+Requires-Dist: page-segmenter>=0.1.2
+Requires-Dist: pydantic-settings>=2.2
+Requires-Dist: pydantic>=2.7
+Requires-Dist: scikit-learn>=1.5
+Requires-Dist: scipy>=1.13
+Requires-Dist: segment-classifier>=0.1.1

component_mapper-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+component_mapper/__init__.py,sha256=kJlD6dEQKNEDSltN6rwgSdd5bC4ZVRXC11zT1neaBnk,152
+component_mapper/config.py,sha256=NFhui7bMMfHv2Tbg_zxvOaYz4fX-SHlC_wX3lv282CU,38662
+component_mapper/models.py,sha256=GOc_B1HlO18YGVAOHyPGMAv8c9ZpBbnN_SeDgUZ4aaU,3875
+component_mapper/pipeline.py,sha256=QwvPrbQcJ7Lw9BL5Cvwog_TaV0fwtsZetX51-Ldc_lw,7039
+component_mapper/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+component_mapper/cache/mapping_cache.py,sha256=Z17DKZEz2uElxhBlIwcdjKAq7h-daeeIF0LpDPfyVdQ,2721
+component_mapper/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+component_mapper/mcp/official_client.py,sha256=_DeuqF2GOHX0Waxxt_MMijQ1hKuRsbuppn7G7jHmffY,6925
+component_mapper/mcp/registry_fetcher.py,sha256=0PFTNngKftXjwxS7EAJ1gFB5oORRbhALB7DBLcoXtdA,8171
+component_mapper/registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+component_mapper/registry/astro_generator.py,sha256=Koswgxdni0WFvVEnnMRWN2hT4UaJJJ2c_x5raBp0clc,12963
+component_mapper/registry/custom_registry.py,sha256=p6oLy7petEGsrQU_BaM2yAJmLvGaLkrtPiW1fpwkivU,4582
+component_mapper/registry/prop_mapper.py,sha256=Eh2sNhFn8hn0i21_tVH7gLyBeW1PY-JIFhFJzyI2eTY,11751
+component_mapper/registry/signature_index.py,sha256=QKa2aGxTtT69tyS0gSYLPeod19hsvuWqqSa8yv_B_kg,24168
+component_mapper/stages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+component_mapper/stages/astro_stage.py,sha256=C-aqtmekq-Ad4_Pcx4P10lU-l0JpMr7TqDbGI-ibRPc,4870
+component_mapper/stages/cache_lookup.py,sha256=QvabZBZtt2bPVKD2VSzMBSOqN7AbVpmzgzm_1iVxvA4,3271
+component_mapper/stages/llm_mapper.py,sha256=5Ei-ONKgFDvY7BaSCHzb2kzFyukN44guSzP_PiM9sP0,18524
+component_mapper/stages/structural_match.py,sha256=VoU9Xy2oYASdvDDzOjj6_CeNTKdX7cXEtxVt-6RvwXc,5114
+component_mapper/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+component_mapper/utils/similarity.py,sha256=pbSWmo21hbcRxg5tsmFshRMpic0NU1ICbugQFvhHI68,2285
+component_mapper/utils/source_parser.py,sha256=oczvBLqC3Z4KxefA75qRQ3jaZjBJtxIwpK78-6qUFaI,9024
+component_mapper-0.1.0.dist-info/METADATA,sha256=A_-xeaSQlRNtJKoXkeVtWNBO0h8dGOuqzGzA-3GW3Rg,522
+component_mapper-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+component_mapper-0.1.0.dist-info/RECORD,,

component_mapper-0.1.0.dist-info/WHEEL

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