codeui-python 0.1.0__py3-none-any.whl

codeui/__init__.py

@@ -0,0 +1,23 @@
+"""codeui: Universal Code-Intelligence Library. Demo Version 18661"""
+from codeui.core.ir import Location, Symbol, SymbolKind, Visibility, EdgeKind, Edge, Finding, Severity
+from codeui.core.graph import Graph
+from codeui.core.override import Override, OverrideKind, OverrideStore
+from codeui.core.repo import get_library_repo_url
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Location",
+    "Symbol",
+    "SymbolKind",
+    "Visibility",
+    "EdgeKind",
+    "Edge",
+    "Finding",
+    "Severity",
+    "Graph",
+    "Override",
+    "OverrideKind",
+    "OverrideStore",
+    "get_library_repo_url",
+]

codeui/agent/__init__.py

@@ -0,0 +1,15 @@
+"""Agent integration and dynamic context builder package for codeui."""
+from codeui.agent.context import ContextBuilder, ContextBundle, TaskSpec
+from codeui.agent.contribution import ContributionManager
+from codeui.agent.edit_tools import EditProposal, EditTools
+from codeui.agent.integrations import CodeUITools
+
+__all__ = [
+    "ContextBuilder",
+    "ContextBundle",
+    "TaskSpec",
+    "ContributionManager",
+    "EditProposal",
+    "EditTools",
+    "CodeUITools",
+]

codeui/agent/context.py

@@ -0,0 +1,207 @@
+"""Dynamic context builder for AI agents based on graph structure."""
+import json
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional, Set, Tuple
+from codeui.core.graph import Graph
+from codeui.core.ir import Edge, Finding, Symbol
+from codeui.errors import SymbolNotFoundError, FileNotFoundInGraphError
+
+@dataclass
+class TaskSpec:
+    """Specification of an AI agent coding task.
+    Example:
+        >>> spec = TaskSpec("Fix bug in main", ["sym_1"], ["app.py"])
+        >>> spec.query
+        'Fix bug in main'
+    """
+    query: str
+    target_symbols: List[str] = field(default_factory=list)
+    target_files: List[str] = field(default_factory=list)
+
+@dataclass
+class ContextBundle:
+    """Compact context payload for LLMs built via graph structure.
+    Example:
+        >>> bundle = ContextBundle({"sym_1": "def f(): pass"}, {"sym_2": "def g():"}, [], [], {"reason": "test"})
+        >>> bundle.manifest["reason"]
+        'test'
+    """
+    symbol_bodies: Dict[str, str]
+    cross_signatures: Dict[str, str]
+    edge_summaries: List[Dict[str, Any]]
+    findings: List[Dict[str, Any]]
+    manifest: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert context bundle to dictionary.
+        Example:
+            >>> bundle = ContextBundle({}, {}, [], [], {})
+            >>> "symbol_bodies" in bundle.to_dict()
+            True
+        """
+        return asdict(self)
+
+    def to_json(self) -> str:
+        """Convert context bundle to deterministic JSON string.
+        Example:
+            >>> bundle = ContextBundle({}, {}, [], [], {})
+            >>> isinstance(bundle.to_json(), str)
+            True
+        """
+        return json.dumps(self.to_dict(), sort_keys=True, indent=2)
+
+class ContextBuilder:
+    """Builds structured dynamic context bundles from graph traversal.
+    Example:
+        >>> g = Graph()
+        >>> builder = ContextBuilder(g)
+        >>> bundle = builder.for_symbol("sym_1", 1)
+        >>> bundle.manifest["status"]
+        'empty'
+    """
+    def __init__(self, graph: Graph) -> None:
+        self.graph = graph
+
+    @staticmethod
+    def _comment_prefix(file_id: str) -> str:
+        lower = file_id.lower()
+        if lower.endswith((".py", ".pyi", ".sh", ".bash", ".zsh", ".yaml", ".yml", ".toml", ".rb")):
+            return "#"
+        if lower.endswith((".sql", ".lua")):
+            return "--"
+        return "//"
+
+    def for_symbol(self, symbol_id: str, depth: int = 1, seen_hashes: Set[str] | None = None) -> ContextBundle:
+        """Build context bundle starting from a symbol outwards by N hops.
+        Example:
+            >>> g = Graph()
+            >>> builder = ContextBuilder(g)
+            >>> bundle = builder.for_symbol("sym_1", 1)
+            >>> "symbol_id" in bundle.manifest
+            True
+        """
+        seen_hashes = seen_hashes or set()
+        if not self.graph.has_symbol(symbol_id):
+            return ContextBundle(
+                symbol_bodies={},
+                cross_signatures={},
+                edge_summaries=[],
+                findings=[],
+                manifest={"symbol_id": symbol_id, "status": "empty", "reason": "symbol_not_found"},
+            )
+        syms, edges = self.graph.get_subgraph(symbol_id, depth=depth)
+        target_sym = self.graph.get_symbol(symbol_id)
+        bodies: Dict[str, str] = {}
+        signatures: Dict[str, str] = {}
+        for s in syms:
+            if s.content_hash in seen_hashes:
+                continue
+            f_id = s.location.file_id if s.location else ""
+            cm = self._comment_prefix(f_id)
+            if s.id == symbol_id:
+                bodies[s.id] = f"{cm} {f_id}:{s.location.start_line if s.location else 1}\n{s.signature or s.name}"
+            else:
+                signatures[s.id] = s.signature or f"{s.kind} {s.name}"
+
+        edge_summaries = [
+            {"source": e.source_id, "target": e.target_id, "kind": str(e.kind)}
+            for e in edges
+        ]
+
+        relevant_findings = [
+            f.to_dict() for f in self.graph.get_findings()
+            if f.symbol_id in {s.id for s in syms} or f.location.file_id == target_sym.location.file_id
+        ]
+
+        manifest = {
+            "symbol_id": symbol_id,
+            "depth": depth,
+            "symbols_included": len(syms),
+            "edges_included": len(edges),
+            "findings_included": len(relevant_findings),
+            "status": "success",
+        }
+        return ContextBundle(
+            symbol_bodies=bodies,
+            cross_signatures=signatures,
+            edge_summaries=edge_summaries,
+            findings=relevant_findings,
+            manifest=manifest,
+        )
+
+    def for_file(self, file_id: str, depth: int = 1, seen_hashes: Set[str] | None = None) -> ContextBundle:
+        """Build context bundle for all symbols in a file.
+        Example:
+            >>> g = Graph()
+            >>> builder = ContextBuilder(g)
+            >>> bundle = builder.for_file("app.py", 1)
+            >>> bundle.manifest["file_id"]
+            'app.py'
+        """
+        seen_hashes = seen_hashes or set()
+        symbols = self.graph.get_symbols_by_file(file_id)
+        bodies: Dict[str, str] = {}
+        cm = self._comment_prefix(file_id)
+        for s in symbols:
+            if s.content_hash not in seen_hashes:
+                bodies[s.id] = f"{cm} {file_id}:{s.location.start_line if s.location else 1}\n{s.signature or s.name}"
+        relevant_findings = [
+            f.to_dict() for f in self.graph.get_findings()
+            if f.location.file_id == file_id
+        ]
+        return ContextBundle(
+            symbol_bodies=bodies,
+            cross_signatures={},
+            edge_summaries=[],
+            findings=relevant_findings,
+            manifest={"file_id": file_id, "symbols_count": len(symbols), "status": "success"},
+        )
+
+    def for_task(self, task: TaskSpec, depth: int = 1) -> ContextBundle:
+        """Build context bundle tailored to a task specification.
+        Example:
+            >>> g = Graph()
+            >>> builder = ContextBuilder(g)
+            >>> spec = TaskSpec("Fix issue")
+            >>> bundle = builder.for_task(spec)
+            >>> "query" in bundle.manifest
+            True
+        """
+        combined_bodies: Dict[str, str] = {}
+        combined_sigs: Dict[str, str] = {}
+        combined_edges: List[Dict[str, Any]] = []
+        combined_findings: List[Dict[str, Any]] = []
+        for sym_id in task.target_symbols:
+            b = self.for_symbol(sym_id, depth=depth)
+            combined_bodies.update(b.symbol_bodies)
+            combined_sigs.update(b.cross_signatures)
+            combined_edges.extend(b.edge_summaries)
+            combined_findings.extend(b.findings)
+        for file_id in task.target_files:
+            b = self.for_file(file_id, depth=depth)
+            combined_bodies.update(b.symbol_bodies)
+            combined_findings.extend(b.findings)
+        return ContextBundle(
+            symbol_bodies=combined_bodies,
+            cross_signatures=combined_sigs,
+            edge_summaries=combined_edges,
+            findings=combined_findings,
+            manifest={"query": task.query, "symbols": task.target_symbols, "files": task.target_files},
+        )
+
+    def for_defect(self, finding_id: str) -> ContextBundle:
+        """Build context bundle targeting a specific defect finding.
+        Example:
+            >>> g = Graph()
+            >>> builder = ContextBuilder(g)
+            >>> bundle = builder.for_defect("f1")
+            >>> bundle.manifest["finding_id"]
+            'f1'
+        """
+        matching = [f for f in self.graph.get_findings() if f.id == finding_id]
+        if not matching:
+            return ContextBundle({}, {}, [], [], {"finding_id": finding_id, "status": "not_found"})
+        f = matching[0]
+        if f.symbol_id:
+            return self.for_symbol(f.symbol_id, depth=1)
+        return self.for_file(f.location.file_id, depth=1)

codeui/agent/contribution.py

@@ -0,0 +1,224 @@
+"""AI agent feedback and repository contribution workflow for codeui."""
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from codeui.core.repo import clone_git_repo, get_library_repo_url
+from codeui.errors import ContributionError, RepositoryCloneError
+
+class ContributionManager:
+    """Manager for AI agents to clone codeui, apply patches, and push modifications.
+    Example:
+        >>> mgr = ContributionManager()
+        >>> mgr.get_repo_url()
+        'https://github.com/AAlsubari/codeUI'
+    """
+    def __init__(
+        self,
+        repo_url: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        self.repo_url = repo_url or get_library_repo_url()
+        self.token = token or os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+
+    def get_repo_url(self) -> str:
+        """Get the target GitHub repository URL.
+        Example:
+            >>> ContributionManager().get_repo_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        return self.repo_url
+
+    def _authenticated_url(self, token: Optional[str] = None) -> str:
+        auth_token = token or self.token
+        url = self.repo_url.strip()
+        if auth_token and url.startswith("https://"):
+            return url.replace("https://", f"https://x-access-token:{auth_token}@")
+        return url
+
+    def clone_repository(
+        self,
+        target_dir: Optional[Union[str, Path]] = None,
+        token: Optional[str] = None,
+        branch: Optional[str] = None,
+    ) -> Path:
+        """Clone the codeui library repository into target or temporary directory.
+        Example:
+            >>> mgr = ContributionManager()
+            >>> isinstance(mgr.get_repo_url(), str)
+            True
+        """
+        auth_url = self._authenticated_url(token)
+        dest = Path(target_dir) if target_dir else None
+        cloned_path, _ = clone_git_repo(auth_url, dest_dir=dest)
+        if branch:
+            git_bin = shutil.which("git") or "git"
+            res = subprocess.run([git_bin, "checkout", branch], cwd=cloned_path, capture_output=True, text=True)
+            if res.returncode != 0:
+                subprocess.run([git_bin, "checkout", "-b", branch], cwd=cloned_path, capture_output=True, text=True)
+        return cloned_path
+
+    def create_feature_branch(self, repo_dir: Union[str, Path], branch_name: str) -> str:
+        """Create and checkout a new branch in the cloned repository.
+        Example:
+            >>> mgr = ContributionManager()
+            >>> mgr.clean_branch_name("Fix Bug #1")
+            'agent/fix-bug-1'
+        """
+        git_bin = shutil.which("git") or "git"
+        p = Path(repo_dir)
+        safe_branch = self.clean_branch_name(branch_name)
+        res = subprocess.run([git_bin, "checkout", "-b", safe_branch], cwd=p, capture_output=True, text=True)
+        if res.returncode != 0:
+            res_co = subprocess.run([git_bin, "checkout", safe_branch], cwd=p, capture_output=True, text=True)
+            if res_co.returncode != 0:
+                raise ContributionError(f"Failed to create branch '{safe_branch}': {res.stderr.strip()}")
+        return safe_branch
+
+    @staticmethod
+    def clean_branch_name(name: str) -> str:
+        """Convert descriptive name into a git-safe branch identifier.
+        Example:
+            >>> ContributionManager.clean_branch_name("Fix AST Edge Leak!")
+            'agent/fix-ast-edge-leak'
+        """
+        raw = name.strip().lower()
+        if raw.startswith("agent/"):
+            raw = raw[6:]
+        slug = re.sub(r"[^a-zA-Z0-9_-]+", "-", raw).strip("-")
+        if not slug:
+            slug = "patch"
+        return f"agent/{slug}"
+
+    def apply_changes(self, repo_dir: Union[str, Path], file_changes: Dict[str, str]) -> List[str]:
+        """Apply modified or new file contents to the repository on disk.
+        Example:
+            >>> import tempfile
+            >>> with tempfile.TemporaryDirectory() as td:
+            ...     mgr = ContributionManager()
+            ...     mgr.apply_changes(td, {"test.txt": "hello"})
+            ['test.txt']
+        """
+        p = Path(repo_dir)
+        applied: List[str] = []
+        for rel_path, content in file_changes.items():
+            target = p / rel_path.lstrip("/\\")
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content, encoding="utf-8")
+            applied.append(rel_path)
+        return applied
+
+    def commit_changes(
+        self,
+        repo_dir: Union[str, Path],
+        message: str,
+        author_name: str = "CodeUI Agent",
+        author_email: str = "agent@codeui.dev",
+    ) -> str:
+        """Stage all modifications and commit with structured commit message.
+        Example:
+            >>> mgr = ContributionManager()
+            >>> mgr.get_repo_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        git_bin = shutil.which("git") or "git"
+        p = Path(repo_dir)
+        subprocess.run([git_bin, "config", "user.name", author_name], cwd=p, capture_output=True, text=True)
+        subprocess.run([git_bin, "config", "user.email", author_email], cwd=p, capture_output=True, text=True)
+        subprocess.run([git_bin, "add", "-A"], cwd=p, capture_output=True, text=True)
+
+        res = subprocess.run([git_bin, "commit", "-m", message], cwd=p, capture_output=True, text=True)
+        if res.returncode != 0 and "nothing to commit" not in res.stdout.lower() and "nothing to commit" not in res.stderr.lower():
+            raise ContributionError(f"Git commit failed: {res.stderr.strip() or res.stdout.strip()}")
+        return message
+
+    def push_changes(
+        self,
+        repo_dir: Union[str, Path],
+        remote: str = "origin",
+        branch: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Push committed changes to remote repository.
+        Example:
+            >>> mgr = ContributionManager()
+            >>> mgr.get_repo_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        git_bin = shutil.which("git") or "git"
+        p = Path(repo_dir)
+        auth_url = self._authenticated_url(token)
+
+        curr_branch = branch
+        if not curr_branch:
+            res_b = subprocess.run([git_bin, "rev-parse", "--abbrev-ref", "HEAD"], cwd=p, capture_output=True, text=True)
+            curr_branch = res_b.stdout.strip() or "main"
+
+        subprocess.run([git_bin, "remote", "set-url", remote, auth_url], cwd=p, capture_output=True, text=True)
+        res_push = subprocess.run([git_bin, "push", "-u", remote, curr_branch], cwd=p, capture_output=True, text=True)
+
+        if res_push.returncode != 0:
+            return {
+                "success": False,
+                "branch": curr_branch,
+                "error": res_push.stderr.strip() or res_push.stdout.strip(),
+                "message": "Push failed, local commit retained.",
+            }
+        return {
+            "success": True,
+            "branch": curr_branch,
+            "error": None,
+            "message": f"Successfully pushed branch {curr_branch} to {self.repo_url}",
+        }
+
+    def submit_contribution(
+        self,
+        title: str,
+        description: str,
+        file_changes: Dict[str, str],
+        branch_name: Optional[str] = None,
+        token: Optional[str] = None,
+        push: bool = True,
+        workspace_dir: Optional[Union[str, Path]] = None,
+    ) -> Dict[str, Any]:
+        """Execute complete contribution flow: clone, branch, edit, commit, and push.
+        Example:
+            >>> mgr = ContributionManager()
+            >>> isinstance(mgr.get_repo_url(), str)
+            True
+        """
+        temp_dir_obj = None
+        if workspace_dir:
+            work_path = Path(workspace_dir).resolve()
+            work_path.mkdir(parents=True, exist_ok=True)
+        else:
+            temp_dir_obj = tempfile.TemporaryDirectory(prefix="codeui_contrib_")
+            work_path = Path(temp_dir_obj.name).resolve()
+
+        push_result: Dict[str, Any] = {"success": False, "message": "Push disabled by caller"}
+        try:
+            cloned_repo = self.clone_repository(target_dir=work_path, token=token)
+            target_branch = self.create_feature_branch(cloned_repo, branch_name or title)
+            applied_files = self.apply_changes(cloned_repo, file_changes)
+
+            commit_msg = f"{title}\n\n{description}\n\nSubmitted by codeui Agent"
+            self.commit_changes(cloned_repo, commit_msg)
+
+            if push:
+                push_result = self.push_changes(cloned_repo, branch=target_branch, token=token)
+
+            return {
+                "status": "pushed" if push_result.get("success") else "committed_locally",
+                "repo_url": self.repo_url,
+                "branch": target_branch,
+                "changed_files": applied_files,
+                "commit_message": commit_msg,
+                "push_result": push_result,
+                "cloned_dir": str(cloned_repo),
+            }
+        finally:
+            if temp_dir_obj and not push_result.get("success"):
+                pass