codegraph-engine 2.3.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

codegraph/search/hybrid.py

@@ -623,6 +623,11 @@ def search_code(
 
     config_exts = {".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf"}
     filtered: list[dict[str, object]] = []
+    seen_file_lines: set[tuple[str, int]] = set()
+    files_with_exact_matches: set[str] = set()
+
+    query_terms = _safe_fts5_terms(clean_query)
+    query_terms_lower = [t.lower() for t in query_terms]
 
     for item in raw_hits:
         rel_path = item.path or item.file
@@ -659,6 +664,27 @@ def search_code(
             d["match_type"] = "case_insensitive"
         else:
             d["match_type"] = "token"
+
+        hit_line = item.line
+        file_line_key = (rel_path, hit_line)
+        if file_line_key in seen_file_lines:
+            continue
+
+        # If multi-word query and this hit is only a token match:
+        # verify that all query terms appear in the snippet or matched text
+        if len(query_terms_lower) >= 2 and d["match_type"] == "token":
+            haystack = (str(d.get("snippet", "")) + " " + str(d.get("matched_text", ""))).lower()
+            if not all(t in haystack for t in query_terms_lower):
+                continue
+
+        # If a file already had an exact/case-insensitive match, discard subsequent loose token matches
+        if rel_path in files_with_exact_matches and d["match_type"] == "token":
+            continue
+
+        if d["match_type"] in ("exact", "case_insensitive"):
+            files_with_exact_matches.add(rel_path)
+
+        seen_file_lines.add(file_line_key)
         filtered.append(d)
         if len(filtered) >= effective_limit:
             break

codegraph/semantic_decorators.py

@@ -66,6 +66,31 @@ _RECOGNIZED_DECORATOR_SPECS: tuple[SemanticDecoratorSpec, ...] = (
         semantic_role="PROVIDES",
         patterns=("provide", "di.provide", "provider", "singleton", "di.singleton"),
     ),
+    SemanticDecoratorSpec(
+        framework="langchain",
+        semantic_role="TOOL_HANDLER",
+        patterns=("tool", "langchain.tools.tool", "langchain_core.tools.tool", "agents.tool"),
+    ),
+    SemanticDecoratorSpec(
+        framework="llama_index",
+        semantic_role="TOOL_HANDLER",
+        patterns=("function_tool", "llama_index.core.tools.function_tool"),
+    ),
+    SemanticDecoratorSpec(
+        framework="ray",
+        semantic_role="TASK_HANDLER",
+        patterns=("ray.remote", "remote"),
+    ),
+    SemanticDecoratorSpec(
+        framework="prefect",
+        semantic_role="TASK_HANDLER",
+        patterns=("prefect.task", "prefect.flow", "task", "flow"),
+    ),
+    SemanticDecoratorSpec(
+        framework="zenml",
+        semantic_role="TASK_HANDLER",
+        patterns=("step", "pipeline"),
+    ),
 )
 
 
@@ -132,12 +157,12 @@ def analyze_symbol_decorators(
                 if "." in raw_expr:
                     base = raw_expr.split(".")[0]
                     # Verify base is imported or standard framework name
-                    if base in import_map or base in ("app", "celery", "click", "django", "typer", "di", "inject"):
+                    if base in import_map or base in ("app", "celery", "click", "django", "typer", "di", "inject", "ray", "langchain", "llama_index", "prefect", "zenml"):
                         grounded_name = raw_expr
                         matched_spec = spec
                         break
                 else:
-                    # Bare name (e.g. shared_task, receiver, command, inject, provide, singleton)
+                    # Bare name (e.g. shared_task, receiver, command, inject, provide, singleton, tool)
                     # Verify it was imported from the framework or known pattern
                     if raw_expr in import_map:
                         imp_mod, imp_orig = import_map[raw_expr]
@@ -146,7 +171,7 @@ def analyze_symbol_decorators(
                             grounded_name = f"{imp_mod}.{orig_or_raw}"
                             matched_spec = spec
                             break
-                    elif raw_expr in ("inject", "provide", "singleton"):
+                    elif raw_expr in ("inject", "provide", "singleton", "receiver", "tool", "function_tool", "remote", "step", "flow"):
                         grounded_name = raw_expr
                         matched_spec = spec
                         break
@@ -242,6 +267,12 @@ def analyze_symbol_decorators(
                     dyn_reason = "dynamic_event_name"
             if event_names:
                 metadata["events"] = event_names
+            for kw in kw_nodes:
+                if kw.arg == "sender":
+                    if isinstance(kw.value, (ast.Name, ast.Attribute)) and hasattr(ast, "unparse"):
+                        metadata["sender"] = ast.unparse(kw.value)
+                    elif isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                        metadata["sender"] = kw.value.value
 
         elif matched_spec.semantic_role == "COMMAND_HANDLER":
             # Extract command name

codegraph/structural_diff.py

@@ -152,6 +152,8 @@ def _run_git(repository: Path, *args: str, timeout: int = 15) -> str | None:
             cwd=str(repository),
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             timeout=timeout,
         )
         return res.stdout if res.returncode == 0 else None

codegraph/styles.py

@@ -0,0 +1,144 @@
+"""CSS, SCSS, and CSS Modules Architecture and Selector Analyzer (Pillar 4).
+
+Extracts deterministic facts from stylesheets:
+- CSS class selectors (.btn-primary, .invoice-card, .header_title)
+- CSS custom properties/variables (--primary-color, --spacing-md)
+- CSS module boundaries
+- Emits Symbol entities for style search and cross-component impact analysis.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from codegraph.indexing.models import Symbol
+
+# CSS Class Selector pattern: .className { or .className:hover or .className.active
+# Excludes decimals like .5s, .75em, .0
+_CSS_CLASS_RE = re.compile(
+    r"""(?<![\w\.\-])\.([A-Za-z_][A-Za-z0-9_-]*)(?=[ \t\r\n\.:,\{>+~])"""
+)
+
+# CSS Custom Property / Variable declaration: --primary-color: #0070f3;
+_CSS_VAR_RE = re.compile(
+    r"""(--[A-Za-z_][A-Za-z0-9_-]*)\s*:"""
+)
+
+# Hex color detector to ignore #fff, #123456 as ID selectors
+_HEX_COLOR_RE = re.compile(r"^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$")
+
+
+@dataclass(frozen=True)
+class CssClassDef:
+    name: str
+    file_path: str
+    line: int
+    is_module: bool
+
+
+@dataclass(frozen=True)
+class CssVariableDef:
+    name: str
+    file_path: str
+    line: int
+
+
+@dataclass(frozen=True)
+class StyleFileResult:
+    classes: tuple[CssClassDef, ...] = ()
+    variables: tuple[CssVariableDef, ...] = ()
+    symbols: tuple[Symbol, ...] = ()
+
+
+def is_style_file(file_path: str) -> bool:
+    """Check if file is a CSS, SCSS, Sass, or Less stylesheet."""
+    lower = file_path.lower()
+    return lower.endswith((".css", ".scss", ".sass", ".less"))
+
+
+def parse_style_file(content: str, file_path: str) -> StyleFileResult:
+    """Extract CSS classes, custom properties, and symbols from stylesheet."""
+    if not is_style_file(file_path):
+        return StyleFileResult()
+
+    is_module = ".module." in file_path.lower()
+    classes: list[CssClassDef] = []
+    variables: list[CssVariableDef] = []
+    symbols: list[Symbol] = []
+
+    seen_classes: set[str] = set()
+    seen_vars: set[str] = set()
+
+    clean_file = file_path.replace("\\", "/").lstrip("./")
+
+    for idx, line in enumerate(content.splitlines()):
+        lineno = idx + 1
+        stripped = line.strip()
+
+        # Skip comment-only lines
+        if stripped.startswith("/*") or stripped.startswith("*") or stripped.startswith("//"):
+            continue
+
+        # Extract CSS variables
+        for m_var in _CSS_VAR_RE.finditer(line):
+            v_name = m_var.group(1)
+            if v_name not in seen_vars:
+                seen_vars.add(v_name)
+                variables.append(CssVariableDef(name=v_name, file_path=clean_file, line=lineno))
+                canon_id = f"{clean_file}::{v_name}"
+                symbols.append(
+                    Symbol(
+                        id=canon_id,
+                        canonical_id=canon_id,
+                        name=v_name,
+                        qualified_name=v_name,
+                        kind="style_var",
+                        language="css",
+                        module=clean_file,
+                        path=clean_file,
+                        file_path=clean_file,
+                        scope="",
+                        start_line=lineno,
+                        end_line=lineno,
+                    )
+                )
+
+        # Extract CSS classes
+        for m_cls in _CSS_CLASS_RE.finditer(line):
+            c_name = m_cls.group(1)
+            # Avoid pseudo-elements and animations
+            if c_name in ("hover", "focus", "active", "visited", "disabled", "first-child", "last-child"):
+                continue
+            if c_name not in seen_classes:
+                seen_classes.add(c_name)
+                classes.append(
+                    CssClassDef(
+                        name=c_name,
+                        file_path=clean_file,
+                        line=lineno,
+                        is_module=is_module,
+                    )
+                )
+                canon_id = f"{clean_file}::{c_name}"
+                symbols.append(
+                    Symbol(
+                        id=canon_id,
+                        canonical_id=canon_id,
+                        name=f".{c_name}",
+                        qualified_name=f".{c_name}",
+                        kind="style_class",
+                        language="css",
+                        module=clean_file,
+                        path=clean_file,
+                        file_path=clean_file,
+                        scope="",
+                        start_line=lineno,
+                        end_line=lineno,
+                    )
+                )
+
+    return StyleFileResult(
+        classes=tuple(classes),
+        variables=tuple(variables),
+        symbols=tuple(symbols),
+    )

codegraph/symbol_history.py

@@ -87,6 +87,8 @@ def _run_git(repository: Path, *args: str, timeout: int = 15) -> str | None:
             cwd=str(repository),
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             timeout=timeout,
         )
         return res.stdout if res.returncode == 0 else None

codegraph/tsconfig.py

@@ -0,0 +1,236 @@
+"""TypeScript and JavaScript Path Alias Resolution (tsconfig.json / jsconfig.json).
+
+Provides deterministic resolution of compilerOptions.paths and baseUrl across
+monorepos, Next.js, Vite, and React projects without external dependencies.
+"""
+from __future__ import annotations
+
+import json
+import posixpath
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def strip_json_comments(text: str) -> str:
+    """Strip single-line and multi-line comments and trailing commas from tsconfig/jsconfig JSON."""
+    # Remove block comments /* ... */
+    text = re.sub(r"/\*[\s\S]*?\*/", "", text)
+    # Remove line comments // ... (not inside quotes)
+    lines: list[str] = []
+    for line in text.splitlines():
+        # Match // not preceded by a quote mark
+        cleaned_line = re.sub(r'(?<![:"\'\\])//.*$', '', line)
+        lines.append(cleaned_line)
+    cleaned = "\n".join(lines)
+    # Remove trailing commas before } or ]
+    cleaned = re.sub(r",\s*([}\]])", r"\1", cleaned)
+    return cleaned
+
+
+@dataclass(frozen=True)
+class TsConfig:
+    config_path: str
+    base_dir: str
+    base_url: str
+    paths: dict[str, tuple[str, ...]] = field(default_factory=dict)
+
+
+class TsConfigResolver:
+    """Manages tsconfig.json and jsconfig.json path mappings across workspaces."""
+
+    def __init__(self, configs: list[TsConfig] | None = None) -> None:
+        self.configs: list[TsConfig] = configs or []
+
+    @classmethod
+    def load_from_repo(cls, repo_root: Path) -> TsConfigResolver:
+        """Scan workspace for tsconfig.json, jsconfig.json, and vite.config.* files."""
+        configs: list[TsConfig] = []
+        candidates = (
+            list(repo_root.glob("**/tsconfig*.json"))
+            + list(repo_root.glob("**/jsconfig*.json"))
+            + list(repo_root.glob("**/vite.config.*"))
+        )
+
+        for c_path in candidates:
+            # Skip node_modules or build outputs
+            parts = c_path.parts
+            if any(p in ("node_modules", ".git", "dist", "build", ".next", ".cache") for p in parts):
+                continue
+            if c_path.name.startswith("vite.config."):
+                cfg = cls._parse_vite_config(c_path, repo_root)
+            else:
+                cfg = cls._parse_single_config(c_path, repo_root)
+            if cfg:
+                configs.append(cfg)
+
+        # Sort configs: deepest path first for nearest-config resolution
+        configs.sort(key=lambda c: len(c.base_dir), reverse=True)
+        return cls(configs)
+
+    @staticmethod
+    def _parse_vite_config(file_path: Path, repo_root: Path) -> TsConfig | None:
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+            parsed_paths: dict[str, tuple[str, ...]] = {}
+
+            # 1. Object alias: alias: { '@': path.resolve(__dirname, './src'), ... }
+            alias_match = re.search(r"alias\s*:\s*\{([^}]+)\}", content)
+            if alias_match:
+                entries = re.findall(
+                    r"""['"]([^'"]+)['"]\s*:\s*(?:(?:path\.)?resolve\([^)]*['"]([^'"]+)['"]\)|['"]([^'"]+)['"])""",
+                    alias_match.group(1),
+                )
+                for key, target1, target2 in entries:
+                    raw_target = (target1 or target2 or "").strip().replace("\\", "/").lstrip("./")
+                    if raw_target:
+                        clean_key = key.rstrip("/")
+                        parsed_paths[f"{clean_key}/*"] = (f"{raw_target}/*",)
+                        parsed_paths[clean_key] = (raw_target,)
+
+            # 2. Array alias: alias: [ { find: '@', replacement: path.resolve(__dirname, './src') } ]
+            array_entries = re.findall(
+                r"""find\s*:\s*['"]([^'"]+)['"][\s\S]*?replacement\s*:\s*(?:(?:path\.)?resolve\([^)]*['"]([^'"]+)['"]\)|['"]([^'"]+)['"])""",
+                content,
+            )
+            for key, target1, target2 in array_entries:
+                raw_target = (target1 or target2 or "").strip().replace("\\", "/").lstrip("./")
+                if raw_target:
+                    clean_key = key.rstrip("/")
+                    parsed_paths[f"{clean_key}/*"] = (f"{raw_target}/*",)
+                    parsed_paths[clean_key] = (raw_target,)
+
+            if not parsed_paths:
+                return None
+
+            base_dir_path = file_path.parent
+            rel_base_dir = posixpath.normpath(base_dir_path.relative_to(repo_root).as_posix())
+            if rel_base_dir == ".":
+                rel_base_dir = ""
+
+            return TsConfig(
+                config_path=posixpath.normpath(file_path.relative_to(repo_root).as_posix()),
+                base_dir=rel_base_dir,
+                base_url=".",
+                paths=parsed_paths,
+            )
+        except Exception:
+            return None
+
+    @staticmethod
+    def _parse_single_config(file_path: Path, repo_root: Path) -> TsConfig | None:
+        try:
+            raw = file_path.read_text(encoding="utf-8", errors="replace")
+            cleaned = strip_json_comments(raw)
+            data = json.loads(cleaned)
+            compiler_opts = data.get("compilerOptions", {})
+
+            base_dir_path = file_path.parent
+            rel_base_dir = posixpath.normpath(base_dir_path.relative_to(repo_root).as_posix())
+            if rel_base_dir == ".":
+                rel_base_dir = ""
+
+            base_url = compiler_opts.get("baseUrl", ".")
+            raw_paths = compiler_opts.get("paths", {})
+
+            parsed_paths: dict[str, tuple[str, ...]] = {}
+            for pattern, targets in raw_paths.items():
+                if isinstance(targets, list):
+                    parsed_paths[pattern] = tuple(str(t) for t in targets)
+                elif isinstance(targets, str):
+                    parsed_paths[pattern] = (targets,)
+
+            if not parsed_paths and base_url in (".", ""):
+                return None
+
+            return TsConfig(
+                config_path=posixpath.normpath(file_path.relative_to(repo_root).as_posix()),
+                base_dir=rel_base_dir,
+                base_url=base_url,
+                paths=parsed_paths,
+            )
+        except Exception:
+            return None
+
+    def resolve_alias(
+        self,
+        imported_module: str,
+        source_file: str,
+        known_files: set[str],
+    ) -> str | None:
+        """Resolve an aliased module (e.g. '@/components/Button') to a file path in known_files."""
+        if not imported_module or imported_module.startswith("."):
+            return None
+
+        clean_src = source_file.replace("\\", "/").lstrip("./")
+
+        # Pick matching config: deepest base_dir matching source_file, or fallback to root config
+        chosen_config: TsConfig | None = None
+        for cfg in self.configs:
+            if not cfg.base_dir or clean_src.startswith(f"{cfg.base_dir}/"):
+                chosen_config = cfg
+                break
+        if not chosen_config and self.configs:
+            chosen_config = self.configs[-1]
+
+        if not chosen_config:
+            return None
+
+        # Check paths mappings
+        for pattern, targets in chosen_config.paths.items():
+            if "*" in pattern:
+                star_idx = pattern.index("*")
+                prefix = pattern[:star_idx]
+                suffix = pattern[star_idx + 1:]
+                if imported_module.startswith(prefix) and (not suffix or imported_module.endswith(suffix)):
+                    wildcard = imported_module[len(prefix):len(imported_module) - len(suffix) if suffix else None]
+                    for target_tmpl in targets:
+                        target = target_tmpl.replace("*", wildcard)
+                        resolved = self._test_target(
+                            chosen_config.base_dir, chosen_config.base_url, target, known_files
+                        )
+                        if resolved:
+                            return resolved
+            else:
+                # Exact match pattern (e.g. "@lib": ["src/lib"])
+                if imported_module == pattern:
+                    for target in targets:
+                        resolved = self._test_target(
+                            chosen_config.base_dir, chosen_config.base_url, target, known_files
+                        )
+                        if resolved:
+                            return resolved
+
+        # Fallback to baseUrl-relative imports if baseUrl is configured
+        if chosen_config.base_url and chosen_config.base_url not in (".", ""):
+            resolved = self._test_target(
+                chosen_config.base_dir, chosen_config.base_url, imported_module, known_files
+            )
+            if resolved:
+                return resolved
+
+        return None
+
+    @staticmethod
+    def _test_target(
+        base_dir: str,
+        base_url: str,
+        target_path: str,
+        known_files: set[str],
+    ) -> str | None:
+        """Check candidate target path against known repository files with extensions and index files."""
+        # Join base_dir, base_url, and target_path in posix style
+        parts = [p for p in (base_dir, base_url, target_path) if p and p not in (".", "")]
+        base = posixpath.normpath("/".join(parts)).lstrip("./")
+
+        candidates = [base]
+        for ext in (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".css", ".scss"):
+            candidates.append(f"{base}{ext}")
+        for idx in ("index.ts", "index.tsx", "index.js", "index.jsx"):
+            candidates.append(posixpath.join(base, idx))
+
+        for cand in candidates:
+            cand_norm = cand.lstrip("./")
+            if cand_norm in known_files:
+                return cand_norm
+        return None

codegraph/ui/__init__.py

@@ -0,0 +1,6 @@
+"""CodeGraph UI module."""
+from __future__ import annotations
+
+from .server import start_ui_server
+
+__all__ = ["start_ui_server"]