codeui-python 0.1.0__py3-none-any.whl

codeui/core/resolver.py

@@ -0,0 +1,281 @@
+"""Project structure and import reference resolution helper."""
+import json
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
+
+class ResolveContext:
+    """Context container for cross-file and cross-language import resolution.
+    Example:
+        >>> ctx = ResolveContext(Path("."))
+        >>> isinstance(ctx.root_path, Path)
+        True
+    """
+    def __init__(self, root_path: Path) -> None:
+        self.root_path = root_path.resolve()
+        self.root_dir = self.root_path
+        self.alias_mappings: Dict[str, str] = {}
+        self.workspace_packages: Dict[str, Path] = {}
+        self.entry_points: List[str] = []
+        self.layer_rules: Dict[str, Any] = {}
+        self._resolve_cache: Dict[Tuple[str, str, str], List[str]] = {}
+        self._known_files: Optional[Set[str]] = None
+        self._search_roots: List[Path] = [self.root_path]
+        self._load_configs()
+
+    def set_known_files(self, files: Iterable[str]) -> None:
+        """Register known project files to accelerate import resolution without disk checks.
+        Example:
+            >>> ctx = ResolveContext(Path("."))
+            >>> ctx.set_known_files(["src/index.ts"])
+            >>> ctx.has_known_file("src/index.ts")
+            True
+        """
+        self._known_files = {f.replace("\\", "/").lstrip("./") for f in files}
+
+    def has_known_file(self, file_path: str) -> bool:
+        """Check if relative path exists in registered known files.
+        Example:
+            >>> ctx = ResolveContext(Path("."))
+            >>> ctx.set_known_files(["a.py"])
+            >>> ctx.has_known_file("a.py")
+            True
+        """
+        if self._known_files is None:
+            return (self.root_path / file_path).exists()
+        return file_path.replace("\\", "/").lstrip("./") in self._known_files
+
+    def _load_configs(self) -> None:
+        """Discover tsconfig.json, package.json, codeui.json, and pyproject.toml configurations."""
+        self._search_roots = [self.root_path]
+        try:
+            for entry in self.root_path.iterdir():
+                if entry.is_dir() and not entry.name.startswith((".", "__")) and entry.name not in ("node_modules", "dist", "build", "target", "vendor", "venv", ".venv"):
+                    self._search_roots.append(entry)
+        except Exception:
+            pass
+
+        codeui_config = self.root_path / ".codeui.json"
+        if not codeui_config.exists():
+            codeui_config = self.root_path / "codeui.json"
+        if codeui_config.exists():
+            try:
+                cdata = json.loads(codeui_config.read_text(encoding="utf-8"))
+                if "entry" in cdata:
+                    entries = cdata["entry"] if isinstance(cdata["entry"], list) else [cdata["entry"]]
+                    self.entry_points.extend(entries)
+                if "entries" in cdata:
+                    self.entry_points.extend(cdata["entries"])
+                if "layers" in cdata and isinstance(cdata["layers"], dict):
+                    self.layer_rules.update(cdata["layers"])
+            except Exception:
+                pass
+
+        tsconfig_path = self.root_path / "tsconfig.json"
+        if tsconfig_path.exists():
+            try:
+                content = tsconfig_path.read_text(encoding="utf-8")
+                data = json.loads(content)
+                compiler_opts = data.get("compilerOptions", {})
+                baseUrl = compiler_opts.get("baseUrl", ".")
+                base_dir = (self.root_path / baseUrl).resolve()
+                paths = compiler_opts.get("paths", {})
+                for alias, targets in paths.items():
+                    alias_clean = alias.rstrip("*").rstrip("/")
+                    if targets and isinstance(targets, list):
+                        target_clean = targets[0].rstrip("*").rstrip("/")
+                        resolved_target = (base_dir / target_clean).resolve()
+                        self.alias_mappings[alias_clean] = str(resolved_target)
+            except Exception:
+                pass
+
+        package_json = self.root_path / "package.json"
+        if not package_json.exists() and self.root_path.parent != self.root_path:
+            parent_pkg = self.root_path.parent / "package.json"
+            if parent_pkg.exists():
+                package_json = parent_pkg
+        if package_json.exists():
+            try:
+                data = json.loads(package_json.read_text(encoding="utf-8"))
+                cui = data.get("codeui") or data.get("appConfig")
+                if cui and isinstance(cui, dict):
+                    if "entry" in cui:
+                        entries = cui["entry"] if isinstance(cui["entry"], list) else [cui["entry"]]
+                        self.entry_points.extend(entries)
+                    if "entries" in cui:
+                        self.entry_points.extend(cui["entries"])
+                    if "layers" in cui and isinstance(cui["layers"], dict):
+                        self.layer_rules.update(cui["layers"])
+                workspaces = data.get("workspaces", [])
+                if isinstance(workspaces, list):
+                    for ws_pattern in workspaces:
+                        ws_clean = ws_pattern.replace("/*", "")
+                        ws_dir = self.root_path / ws_clean
+                        if ws_dir.exists() and ws_dir.is_dir():
+                            for sub in ws_dir.iterdir():
+                                sub_pkg = sub / "package.json"
+                                if sub_pkg.exists():
+                                    sub_data = json.loads(sub_pkg.read_text(encoding="utf-8"))
+                                    pkg_name = sub_data.get("name")
+                                    if pkg_name:
+                                        self.workspace_packages[pkg_name] = sub.resolve()
+            except Exception:
+                pass
+
+    def resolve_path(self, current_file: str, import_path: str, language: str = "") -> List[str]:
+        """Resolve import reference string to candidate file paths relative to root.
+        Example:
+            >>> ctx = ResolveContext(Path("."))
+            >>> candidates = ctx.resolve_path("src/app.ts", "./utils", "typescript")
+            >>> isinstance(candidates, list)
+            True
+        """
+        cache_key = (current_file, import_path, language)
+        if cache_key in self._resolve_cache:
+            return self._resolve_cache[cache_key]
+
+        resolved: List[str] = []
+        current_dir = (self.root_path / Path(current_file).parent).resolve() if current_file else self.root_path
+        clean_mod = import_path.replace("module::", "").replace("import:", "").strip()
+
+        if clean_mod.startswith("."):
+            num_dots = len(clean_mod) - len(clean_mod.lstrip("."))
+            rest = clean_mod.lstrip(".")
+            target_dir = current_dir
+            for _ in range(num_dots - 1):
+                if target_dir.parent and target_dir.parent != target_dir:
+                    target_dir = target_dir.parent
+
+            parts = [p for p in rest.split(".") if p]
+            if not parts:
+                candidate_paths = [target_dir / "__init__.py", target_dir / "index.ts", target_dir / "index.js"]
+            else:
+                sub_str = "/".join(parts)
+                parent_sub = "/".join(parts[:-1]) if len(parts) > 1 else ""
+                candidate_paths = [
+                    target_dir / f"{sub_str}.py",
+                    target_dir / f"{sub_str}.ts",
+                    target_dir / f"{sub_str}.js",
+                    target_dir / sub_str / "__init__.py",
+                    target_dir / sub_str / "index.ts",
+                    target_dir / sub_str / "index.js",
+                ]
+                if parent_sub:
+                    candidate_paths.extend([
+                        target_dir / f"{parent_sub}.py",
+                        target_dir / f"{parent_sub}.ts",
+                        target_dir / f"{parent_sub}.js",
+                        target_dir / parent_sub / "__init__.py",
+                    ])
+            for cp in candidate_paths:
+                if self._known_files is not None:
+                    try:
+                        rel = str(cp.relative_to(self.root_path)).replace("\\", "/")
+                        if rel in self._known_files:
+                            resolved.append(rel)
+                    except (ValueError, RuntimeError):
+                        pass
+                else:
+                    if cp.exists() and cp.is_file():
+                        try:
+                            resolved.append(str(cp.resolve().relative_to(self.root_path)).replace("\\", "/"))
+                        except (ValueError, RuntimeError):
+                            pass
+
+        for alias, target in self.alias_mappings.items():
+            if import_path.startswith(alias):
+                rel = import_path[len(alias):].lstrip("/")
+                base = Path(target) / rel
+                from codeui.lang.registry import LanguageRegistry
+                extensions = sorted(list(LanguageRegistry().get_supported_extensions() | {".ts", ".tsx", ".js", ".jsx", ".py"}))
+                for ext in extensions:
+                    p = base.with_suffix(ext)
+                    if self._known_files is not None:
+                        try:
+                            rel_p = str(p.relative_to(self.root_path)).replace("\\", "/")
+                            if rel_p in self._known_files:
+                                resolved.append(rel_p)
+                        except (ValueError, RuntimeError):
+                            pass
+                    else:
+                        if p.exists() and p.is_file():
+                            try:
+                                resolved.append(str(p.resolve().relative_to(self.root_path)).replace("\\", "/"))
+                            except (ValueError, RuntimeError):
+                                pass
+
+        for pkg_name, pkg_path in self.workspace_packages.items():
+            if import_path == pkg_name or import_path.startswith(pkg_name + "/"):
+                rel = import_path[len(pkg_name):].lstrip("/")
+                base = pkg_path / (rel if rel else "src/index.ts")
+                if self._known_files is not None:
+                    try:
+                        rel_base = str(base.relative_to(self.root_path)).replace("\\", "/")
+                        if rel_base in self._known_files:
+                            resolved.append(rel_base)
+                    except (ValueError, RuntimeError):
+                        pass
+                else:
+                    if base.exists() and base.is_file():
+                        try:
+                            resolved.append(str(base.resolve().relative_to(self.root_path)).replace("\\", "/"))
+                        except (ValueError, RuntimeError):
+                            pass
+
+        clean_mod = import_path.replace("module::", "").replace("import:", "").strip()
+        if not clean_mod.startswith("."):
+            mod_path_str = clean_mod.replace(".", "/")
+            parts = [p for p in mod_path_str.split("/") if p]
+            from codeui.lang.registry import LanguageRegistry
+            code_extensions = sorted(list(LanguageRegistry().get_supported_extensions() | {".py", ".ts", ".tsx", ".js", ".jsx", ".go", ".rs", ".mjs", ".cjs"}))
+            index_filenames = ["__init__.py", "index.ts", "index.tsx", "index.js", "index.jsx", "mod.rs", "lib.rs"]
+
+            if self._known_files is not None:
+                search_root_prefixes = [""] + [f"{r.name}/" for r in self._search_roots if r != self.root_path]
+                for i in range(len(parts)):
+                    sub_str = "/".join(parts[i:])
+                    parent_sub = "/".join(parts[i:-1]) if len(parts[i:]) > 1 else ""
+                    for prefix in search_root_prefixes:
+                        for ext in code_extensions:
+                            cand1 = f"{prefix}{sub_str}{ext}"
+                            if cand1 in self._known_files:
+                                resolved.append(cand1)
+                            if parent_sub:
+                                cand2 = f"{prefix}{parent_sub}{ext}"
+                                if cand2 in self._known_files:
+                                    resolved.append(cand2)
+                        for idx_name in index_filenames:
+                            cand3 = f"{prefix}{sub_str}/{idx_name}"
+                            if cand3 in self._known_files:
+                                resolved.append(cand3)
+                            if parent_sub:
+                                cand4 = f"{prefix}{parent_sub}/{idx_name}"
+                                if cand4 in self._known_files:
+                                    resolved.append(cand4)
+                    if resolved:
+                        break
+            else:
+                candidate_paths: List[Path] = []
+                for i in range(len(parts)):
+                    sub_parts = parts[i:]
+                    sub_str = "/".join(sub_parts)
+                    parent_sub = "/".join(sub_parts[:-1]) if len(sub_parts) > 1 else ""
+                    for root in self._search_roots:
+                        for ext in code_extensions:
+                            candidate_paths.append(root / f"{sub_str}{ext}")
+                            if parent_sub:
+                                candidate_paths.append(root / f"{parent_sub}{ext}")
+                        for idx_name in index_filenames:
+                            candidate_paths.append(root / sub_str / idx_name)
+                            if parent_sub:
+                                candidate_paths.append(root / parent_sub / idx_name)
+
+                for cp in candidate_paths:
+                    if cp.exists() and cp.is_file():
+                        try:
+                            resolved.append(str(cp.resolve().relative_to(self.root_path)).replace("\\", "/"))
+                        except (ValueError, RuntimeError):
+                            pass
+
+        result = list(dict.fromkeys(resolved))
+        self._resolve_cache[cache_key] = result
+        return result

codeui/errors.py

@@ -0,0 +1,98 @@
+"""Typed exception hierarchy for codeui errors."""
+
+class CodeUIError(Exception):
+    """Base class for all codeui exceptions.
+    Example:
+        >>> err = CodeUIError("An error occurred")
+        >>> str(err)
+        'An error occurred'
+    """
+    pass
+
+class SymbolNotFoundError(CodeUIError):
+    """Raised when a requested symbol cannot be found in the graph.
+    Example:
+        >>> err = SymbolNotFoundError("sym_123")
+        >>> err.symbol_id
+        'sym_123'
+    """
+    def __init__(self, symbol_id: str) -> None:
+        super().__init__(f"Symbol not found: {symbol_id}")
+        self.symbol_id = symbol_id
+
+class FileNotFoundInGraphError(CodeUIError):
+    """Raised when a requested file cannot be found in the graph.
+    Example:
+        >>> err = FileNotFoundInGraphError("src/index.ts")
+        >>> err.file_id
+        'src/index.ts'
+    """
+    def __init__(self, file_id: str) -> None:
+        super().__init__(f"File not found in graph: {file_id}")
+        self.file_id = file_id
+
+class OverrideConflictError(CodeUIError):
+    """Raised when an override target has changed on disk.
+    Example:
+        >>> err = OverrideConflictError("src/app.ts", "hash_a", "hash_b")
+        >>> err.file_path
+        'src/app.ts'
+    """
+    def __init__(self, file_path: str, expected_hash: str, actual_hash: str) -> None:
+        super().__init__(f"Override conflict on {file_path}: expected {expected_hash}, got {actual_hash}")
+        self.file_path = file_path
+        self.expected_hash = expected_hash
+        self.actual_hash = actual_hash
+
+class ValidationError(CodeUIError):
+    """Raised when edit validation or IR validation fails.
+    Example:
+        >>> err = ValidationError("Syntax error in edit")
+        >>> str(err)
+        'Syntax error in edit'
+    """
+    pass
+
+class SecurityError(CodeUIError):
+    """Raised when path traversal or CSRF security checks fail.
+    Example:
+        >>> err = SecurityError("Path traversal blocked")
+        >>> str(err)
+        'Path traversal blocked'
+    """
+    pass
+
+class ParseError(CodeUIError):
+    """Raised when language parsing fails.
+    Example:
+        >>> err = ParseError("main.py", 10, 5, "Unexpected token")
+        >>> err.line
+        10
+    """
+    def __init__(self, file_path: str, line: int, col: int, message: str) -> None:
+        super().__init__(f"Parse error in {file_path}:{line}:{col}: {message}")
+        self.file_path = file_path
+        self.line = line
+        self.col = col
+        self.message = message
+
+class RepositoryCloneError(CodeUIError):
+    """Raised when cloning a remote repository fails.
+    Example:
+        >>> err = RepositoryCloneError("https://github.com/invalid/repo", "fatal: repository not found")
+        >>> err.repo_url
+        'https://github.com/invalid/repo'
+    """
+    def __init__(self, repo_url: str, message: str) -> None:
+        super().__init__(f"Failed to clone repository '{repo_url}': {message}")
+        self.repo_url = repo_url
+        self.message = message
+
+class ContributionError(CodeUIError):
+    """Raised when AI agent contribution or git mutation fails.
+    Example:
+        >>> err = ContributionError("Failed to push changes")
+        >>> str(err)
+        'Failed to push changes'
+    """
+    pass

codeui/lang/__init__.py

@@ -0,0 +1 @@
+"""Language adapters package for codeui."""

codeui/lang/base.py

@@ -0,0 +1,117 @@
+"""Base interface for language AST adapters."""
+import hashlib
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar, Iterable, List, Sequence
+from codeui.core.ir import Edge, Location, Symbol
+from codeui.core.resolver import ResolveContext
+
+@dataclass
+class ParseResult:
+    """Encapsulates parse AST result and errors.
+    Example:
+        >>> res = ParseResult("app.py", "x = 1", None, "hash1", [])
+        >>> res.file_path
+        'app.py'
+    """
+    file_path: str
+    source: str
+    ast: Any
+    content_hash: str
+    errors: List[str]
+
+@dataclass
+class ImportRef:
+    """Import reference descriptor.
+    Example:
+        >>> ref = ImportRef("app.py", "math", None, False)
+        >>> ref.module_name
+        'math'
+    """
+    file_path: str
+    module_name: str
+    symbol_name: str | None
+    is_relative: bool
+
+class LanguageAnalyzer(ABC):
+    """Abstract base class for language analyzers.
+    Example:
+        >>> class MockLang(LanguageAnalyzer):
+        ...     language = "mock"
+        ...     extensions = (".mock",)
+        ...     def parse(self, path, source): return ParseResult(str(path), source, None, "h", [])
+        ...     def extract_symbols(self, parse): return []
+        ...     def extract_edges(self, parse, symbols): return []
+        ...     def resolve_import(self, ref, ctx): return []
+        >>> mock = MockLang()
+        >>> mock.language
+        'mock'
+    """
+    language: ClassVar[str]
+    extensions: ClassVar[tuple[str, ...]]
+    has_ast_support: ClassVar[bool] = True
+    is_supported: ClassVar[bool] = True
+
+    @abstractmethod
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse source code into AST payload."""
+        pass
+
+    @abstractmethod
+    def extract_symbols(self, parse: ParseResult) -> Iterable[Symbol]:
+        """Extract symbol hierarchy from parse result."""
+        pass
+
+    @abstractmethod
+    def extract_edges(self, parse: ParseResult, symbols: Sequence[Symbol]) -> Iterable[Edge]:
+        """Extract relationship edges between symbols."""
+        pass
+
+    @abstractmethod
+    def resolve_import(self, ref: ImportRef, ctx: ResolveContext) -> Iterable[str]:
+        """Resolve import reference to candidate project files."""
+        pass
+
+    def _extract_body_hash(self, lines: Sequence[str], start_idx: int) -> str:
+        """Extract a deterministic hash of code body starting at start_idx."""
+        snippet_lines = []
+        brace_count = 0
+        found_open = False
+        for i in range(start_idx, min(len(lines), start_idx + 80)):
+            l = lines[i]
+            snippet_lines.append(l)
+            brace_count += l.count("{") - l.count("}")
+            if "{" in l:
+                found_open = True
+            if found_open and brace_count <= 0:
+                break
+        body = "\n".join(snippet_lines).strip()
+        if not body and start_idx < len(lines):
+            body = lines[start_idx].strip()
+        return hashlib.sha256(body.encode("utf-8")).hexdigest()[:16]
+
+    def _find_block_end(self, lines: Sequence[str], start_idx: int) -> int:
+        """Find the 1-based end line of a block starting at 0-based start_idx.
+        Example:
+            >>> class MockLang(LanguageAnalyzer):
+            ...     language = "mock"
+            ...     extensions = ()
+            ...     def parse(self, p, s): pass
+            ...     def extract_symbols(self, p): pass
+            ...     def extract_edges(self, p, s): pass
+            ...     def resolve_import(self, r, c): pass
+            >>> m = MockLang()
+            >>> m._find_block_end(["func foo() {", "  return 1", "}"], 0)
+            3
+        """
+        brace_count = 0
+        found_open = False
+        for i in range(start_idx, len(lines)):
+            l = lines[i]
+            brace_count += l.count("{") - l.count("}")
+            if "{" in l:
+                found_open = True
+            if found_open and brace_count <= 0:
+                return i + 1
+        return min(len(lines), start_idx + 1)

codeui/lang/generic.py

@@ -0,0 +1,90 @@
+"""Generic markup, config, and fallback language analyzer for codeui."""
+import hashlib
+from pathlib import Path
+from typing import ClassVar, Iterable, List, Sequence
+from codeui.core.ir import Edge, EdgeKind, Location, Symbol, SymbolKind, Visibility
+from codeui.core.resolver import ResolveContext
+from codeui.lang.base import ImportRef, LanguageAnalyzer, ParseResult
+
+class GenericLanguageAnalyzer(LanguageAnalyzer):
+    """Fallback analyzer for configuration, markup, and generic source files.
+    Example:
+        >>> analyzer = GenericLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("config.json"), '{"key": "value"}')
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> len(syms) == 1
+        True
+    """
+    language: ClassVar[str] = "generic"
+    has_ast_support: ClassVar[bool] = False
+    is_supported: ClassVar[bool] = False
+    extensions: ClassVar[tuple[str, ...]] = (
+        ".java", ".kt", ".cs", ".rb", ".php", ".swift", ".vue", ".svelte",
+        ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".m", ".mm", ".scala"
+    )
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse source into generic result.
+        Example:
+            >>> analyzer = GenericLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("README.md"), "# Hello")
+            >>> res.errors
+            []
+        """
+        content_hash = hashlib.sha256(source.encode("utf-8")).hexdigest()
+        return ParseResult(
+            file_path=str(path),
+            source=source,
+            ast=source,
+            content_hash=content_hash,
+            errors=[],
+        )
+
+    def extract_symbols(self, parse: ParseResult) -> Iterable[Symbol]:
+        """Extract top-level FILE symbol for generic documents.
+        Example:
+            >>> analyzer = GenericLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("a.txt"), "hello")
+            >>> syms = list(analyzer.extract_symbols(res))
+            >>> syms[0].kind == SymbolKind.FILE
+            True
+        """
+        file_path = parse.file_path
+        lines = parse.source.splitlines()
+        max_line = len(lines) if lines else 1
+        return [
+            Symbol(
+                id=file_path,
+                name=Path(file_path).name,
+                qualified_name=file_path,
+                kind=SymbolKind.FILE,
+                language=self.language,
+                location=Location(file_path, 1, 0, max_line, 0),
+                parent_id=None,
+                signature=None,
+                visibility=Visibility.PUBLIC,
+                modifiers=(),
+                content_hash=parse.content_hash,
+            )
+        ]
+
+    def extract_edges(self, parse: ParseResult, symbols: Sequence[Symbol]) -> Iterable[Edge]:
+        """Extract edges for generic files (empty set).
+        Example:
+            >>> analyzer = GenericLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("a.txt"), "hello")
+            >>> list(analyzer.extract_edges(res, []))
+            []
+        """
+        return []
+
+    def resolve_import(self, ref: ImportRef, ctx: ResolveContext) -> Iterable[str]:
+        """Resolve import references for generic files.
+        Example:
+            >>> analyzer = GenericLanguageAnalyzer()
+            >>> ctx = ResolveContext(Path("."))
+            >>> ref = ImportRef("a.txt", "b", None, False)
+            >>> list(analyzer.resolve_import(ref, ctx))
+            []
+        """
+        return []