codeui-python 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

codeui/__init__.py

@@ -4,7 +4,7 @@ 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"
+__version__ = "0.1.1"
 
 __all__ = [
     "Location",

codeui/agent/context.py

@@ -110,7 +110,9 @@ class ContextBuilder:
 
         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
+            if (f.symbol_id and f.symbol_id in {s.id for s in syms}) or (
+                f.location and target_sym.location and f.location.file_id == target_sym.location.file_id
+            )
         ]
 
         manifest = {
@@ -147,7 +149,7 @@ class ContextBuilder:
                 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
+            if f.location and f.location.file_id == file_id
         ]
         return ContextBundle(
             symbol_bodies=bodies,
@@ -189,6 +191,18 @@ class ContextBuilder:
             manifest={"query": task.query, "symbols": task.target_symbols, "files": task.target_files},
         )
 
+    def build_context(self, task: TaskSpec, depth: int = 1) -> ContextBundle:
+        """Alias for for_task to build context bundle.
+        Example:
+            >>> g = Graph()
+            >>> builder = ContextBuilder(g)
+            >>> spec = TaskSpec("Fix issue")
+            >>> bundle = builder.build_context(spec)
+            >>> "query" in bundle.manifest
+            True
+        """
+        return self.for_task(task, depth=depth)
+
     def for_defect(self, finding_id: str) -> ContextBundle:
         """Build context bundle targeting a specific defect finding.
         Example:
@@ -204,4 +218,6 @@ class ContextBuilder:
         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)
+        if f.location and f.location.file_id:
+            return self.for_file(f.location.file_id, depth=1)
+        return ContextBundle({}, {}, [], [], {"finding_id": finding_id, "status": "no_location"})

codeui/analysis/dead_code.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import ClassVar, Iterable, List, Set
 from codeui.analysis.base import AnalysisContext, Analyzer
 from codeui.core.graph import Graph
-from codeui.core.ir import EdgeKind, Finding, Location, Severity, SymbolKind, Visibility
+from codeui.core.ir import EdgeKind, Finding, LayerKind, Location, Severity, SymbolKind, Visibility
 
 class DeadCodeAnalyzer(Analyzer):
     """Detects unused functions, unused private symbols, and orphan files.
@@ -22,7 +22,10 @@ class DeadCodeAnalyzer(Analyzer):
         "__init__", "__post_init__", "__str__", "__repr__", "__eq__", "__hash__",
         "__iter__", "__getitem__", "__setitem__", "__delitem__", "__len__",
         "__contains__", "__enter__", "__exit__", "__call__", "__await__",
-        "constructor", "init", "dispose", "render", "setup", "teardown", "setUp", "tearDown"
+        "constructor", "init", "dispose", "render", "build", "initialize",
+        "setup", "teardown", "setUp", "tearDown", "beforeEach", "afterEach",
+        "beforeAll", "afterAll", "onCreate", "onDestroy", "onStart", "onStop",
+        "onResume", "onPause", "componentDidMount", "componentWillUnmount"
     }
 
     def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
@@ -43,6 +46,14 @@ class DeadCodeAnalyzer(Analyzer):
                 referenced_targets.add(raw_target.split(".")[-1])
 
         for sym in graph.get_all_symbols():
+            if sym.location and sym.location.file_id:
+                cls = graph.get_file_classification(sym.location.file_id)
+                if cls.layer in (LayerKind.TEST, LayerKind.CONFIG):
+                    continue
+                file_lower = sym.location.file_id.replace("\\", "/").lower()
+                if any(p in file_lower for p in ("/tests/", "/test/", "/benches/", "/bench/", "/examples/", "/example/", "/fixtures/")):
+                    continue
+
             if sym.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD, SymbolKind.CLASS):
                 if sym.name in self.ENTRY_POINTS or any(sym.name.startswith(p) for p in self.ENTRY_POINTS):
                     continue

codeui/analysis/undefined.py

@@ -76,10 +76,80 @@ class UndefinedSymbolAnalyzer(Analyzer):
                 if "." in target_name:
                     continue
 
+                local_names = set()
+                try:
+                    caller_sym = graph.get_symbol(edge.source_id)
+                    if caller_sym and caller_sym.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD):
+                        file_path = ctx.root_dir / caller_sym.location.file_id
+                        if file_path.exists():
+                            import ast
+                            source = file_path.read_text(encoding="utf-8")
+                            tree = ast.parse(source)
+                            for node in ast.walk(tree):
+                                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.lineno == caller_sym.location.start_line:
+                                    for arg in getattr(node.args, "posonlyargs", []) + getattr(node.args, "args", []) + getattr(node.args, "kwonlyargs", []):
+                                        if hasattr(arg, "arg"):
+                                            local_names.add(arg.arg)
+                                    if getattr(node.args, "vararg", None):
+                                        local_names.add(node.args.vararg.arg)
+                                    if getattr(node.args, "kwarg", None):
+                                        local_names.add(node.args.kwarg.arg)
+                                    
+                                    for subnode in ast.walk(node):
+                                        if isinstance(subnode, ast.Assign):
+                                            for target in subnode.targets:
+                                                if isinstance(target, ast.Name):
+                                                    local_names.add(target.id)
+                                                elif isinstance(target, (ast.Tuple, ast.List)):
+                                                    def _ext_names(t):
+                                                        res = set()
+                                                        if isinstance(t, ast.Name): res.add(t.id)
+                                                        elif isinstance(t, (ast.Tuple, ast.List)):
+                                                            for e in t.elts: res.update(_ext_names(e))
+                                                        return res
+                                                    local_names.update(_ext_names(target))
+                                        elif isinstance(subnode, ast.AnnAssign):
+                                            if isinstance(subnode.target, ast.Name):
+                                                local_names.add(subnode.target.id)
+                                        elif isinstance(subnode, (ast.For, ast.AsyncFor)):
+                                            def _ext_names(t):
+                                                res = set()
+                                                if isinstance(t, ast.Name): res.add(t.id)
+                                                elif isinstance(t, (ast.Tuple, ast.List)):
+                                                    for e in t.elts: res.update(_ext_names(e))
+                                                return res
+                                            local_names.update(_ext_names(subnode.target))
+                                        elif isinstance(subnode, (ast.With, ast.AsyncWith)):
+                                            for item in subnode.items:
+                                                if item.optional_vars:
+                                                    def _ext_names(t):
+                                                        res = set()
+                                                        if isinstance(t, ast.Name): res.add(t.id)
+                                                        elif isinstance(t, (ast.Tuple, ast.List)):
+                                                            for e in t.elts: res.update(_ext_names(e))
+                                                        return res
+                                                    local_names.update(_ext_names(item.optional_vars))
+                                        elif isinstance(subnode, ast.ExceptHandler):
+                                            if subnode.name:
+                                                local_names.add(subnode.name)
+                                        elif isinstance(subnode, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+                                            for gen in subnode.generators:
+                                                def _ext_names(t):
+                                                    res = set()
+                                                    if isinstance(t, ast.Name): res.add(t.id)
+                                                    elif isinstance(t, (ast.Tuple, ast.List)):
+                                                        for e in t.elts: res.update(_ext_names(e))
+                                                    return res
+                                                local_names.update(_ext_names(gen.target))
+                                    break
+                except Exception:
+                    pass
+
                 if (
                     not graph.has_symbol(target_id)
                     and target_name not in all_symbol_names
                     and target_name not in file_imports.get(src_file, set())
+                    and target_name not in local_names
                     and not target_name.startswith("_")
                 ):
                     loc = edge.location or Location(edge.source_id, 1, 0, 1, 0)

codeui/analysis/unresolved_import.py

@@ -58,8 +58,20 @@ class UnresolvedImportAnalyzer(Analyzer):
                     known_deps.add(stem)
                     known_deps.add(p)
 
+        top_level_items = set()
         if ctx and ctx.root_dir:
             root = ctx.root_dir
+            try:
+                for item in root.iterdir():
+                    top_level_items.add(item.name)
+                    top_level_items.add(item.stem)
+                    if item.name == "src" and item.is_dir():
+                        for subitem in item.iterdir():
+                            top_level_items.add(subitem.name)
+                            top_level_items.add(subitem.stem)
+            except Exception:
+                pass
+
             for manifest_name in ("package.json", "requirements.txt", "pyproject.toml", "setup.py", "Pipfile", "go.mod", "Cargo.toml"):
                 mpath = root / manifest_name
                 if mpath.exists():
@@ -104,17 +116,35 @@ class UnresolvedImportAnalyzer(Analyzer):
                     or any(raw_mod in f or base_mod in f for f in all_files)
                 )
 
+                is_internal = False
+                if base_mod in top_level_items:
+                    is_internal = True
+                else:
+                    for f in all_files:
+                        f_clean = f.replace("\\", "/")
+                        if f_clean.startswith(base_mod + "/") or f_clean == base_mod or ("/" + base_mod + "/") in f_clean:
+                            is_internal = True
+                            break
+                
+                if not is_internal and base_mod != "@" and base_mod != "":
+                    is_known = True
+
                 if not is_known and raw_mod.startswith("@/"):
                     as_src = "src/" + raw_mod[2:]
                     as_root = raw_mod[2:]
                     if any(as_src in f or as_root in f for f in all_files):
                         is_known = True
 
-                if not is_known and hasattr(ctx, "resolve_path"):
+                if not is_known:
                     src_file = edge.source_id.split("::")[0]
-                    resolved = ctx.resolve_path(src_file, raw_mod)
-                    if resolved:
-                        is_known = True
+                    if hasattr(ctx, "resolve_path"):
+                        resolved = ctx.resolve_path(src_file, raw_mod)
+                        if resolved:
+                            is_known = True
+                    elif hasattr(ctx, "resolve_context") and ctx.resolve_context and hasattr(ctx.resolve_context, "resolve_path"):
+                        resolved = ctx.resolve_context.resolve_path(src_file, raw_mod)
+                        if resolved:
+                            is_known = True
 
                 if not is_known and hasattr(ctx, "alias_mappings"):
                     for alias, target in getattr(ctx, "alias_mappings", {}).items():

codeui/cli/main.py

@@ -27,6 +27,7 @@ def scan_project(
     project_path: Union[str, Path],
     entry_points: Optional[Sequence[str]] = None,
     layer_rules: Optional[Dict[str, Any]] = None,
+    clean_cache: bool = False,
 ) -> Graph:
     """Scan a project directory or remote Git repository and build the universal graph.
     Example:
@@ -46,9 +47,12 @@ def scan_project(
         graph = Graph()
         registry = LanguageRegistry()
         ctx = ResolveContext(resolved_project_path)
+        ctx.set_supported_extensions(registry.get_all_extensions())
         cache_db_path = resolved_project_path / ".codeui" / "cache.db"
         try:
             cache = AnalysisCache(cache_db_path)
+            if clean_cache:
+                cache.clear()
         except Exception:
             cache = None
 
@@ -96,6 +100,13 @@ def scan_project(
                     continue
                 all_files.append(p)
 
+        if cache:
+            valid_rel_paths = {
+                str(p.relative_to(resolved_project_path)).replace("\\", "/")
+                for p in all_files
+            }
+            cache.prune_stale(valid_rel_paths)
+
         parsed_files: Set[str] = set()
         raw_edges: List[Edge] = []
         for p in all_files:
@@ -196,6 +207,56 @@ def scan_project(
         if temp_clone_obj:
             temp_clone_obj.cleanup()
 
+def export_pages(
+    project_path: Union[str, Path] = ".",
+    out_dir: Union[str, Path] = "dist",
+    entry_points: Optional[Sequence[str]] = None,
+    clean_cache: bool = False,
+) -> Path:
+    """Export static code graph and report artifacts for standalone browser preview.
+    Example:
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as td:
+        ...     out = export_pages(Path("."), Path(td) / "dist")
+        ...     out.exists()
+        True
+    """
+    resolved_proj = Path(project_path).resolve()
+    resolved_out = Path(out_dir).resolve()
+    resolved_out.mkdir(parents=True, exist_ok=True)
+
+    g = scan_project(resolved_proj, entry_points=entry_points, clean_cache=clean_cache)
+
+    (resolved_out / "graph.json").write_text(JSONEmitter().emit(g), encoding="utf-8")
+
+    ctx = AnalysisContext(resolved_proj)
+    findings = [f.to_dict() for f in AnalysisRunner().run_all(g, ctx)]
+    (resolved_out / "defects.json").write_text(
+        json.dumps({"findings": findings, "count": len(findings)}, indent=2),
+        encoding="utf-8",
+    )
+
+    static_src = Path(__file__).resolve().parent.parent / "server" / "static"
+    if static_src.exists():
+        static_out = resolved_out / "static"
+        static_out.mkdir(parents=True, exist_ok=True)
+        for item in static_src.rglob("*"):
+            if item.is_file() and item.name != "index.html":
+                rel = item.relative_to(static_src)
+                dest = static_out / rel
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                dest.write_bytes(item.read_bytes())
+
+        index_src = static_src / "index.html"
+        if index_src.exists():
+            html_text = index_src.read_text(encoding="utf-8")
+            html_text = html_text.replace('href="/static/', 'href="static/')
+            html_text = html_text.replace('src="/static/', 'src="static/')
+            (resolved_out / "index.html").write_text(html_text, encoding="utf-8")
+
+    (resolved_out / ".nojekyll").touch(exist_ok=True)
+    return resolved_out
+
 def main(args: Optional[List[str]] = None) -> int:
     """Main CLI entrypoint.
     Example:
@@ -209,16 +270,25 @@ def main(args: Optional[List[str]] = None) -> int:
     parser = argparse.ArgumentParser(prog="codeui", description="Universal code-intelligence engine", parents=[parent_parser])
     subparsers = parser.add_subparsers(dest="command")
 
-    subparsers.add_parser("init", parents=[parent_parser], help="Initialize .codeui configuration")
+    init_p = subparsers.add_parser("init", parents=[parent_parser], help="Initialize .codeui workspace directory")
+    init_p.add_argument("project", nargs="?", default=".", help="Project path")
 
     scan_p = subparsers.add_parser("scan", parents=[parent_parser], help="Scan project and build code graph")
     scan_p.add_argument("project", nargs="?", default=".", help="Project path")
     scan_p.add_argument("--entry", action="append", help="Explicit application entry point(s)")
     scan_p.add_argument("--out", default=".codeui", help="Output cache directory")
+    scan_p.add_argument("--clean-cache", action="store_true", help="Clear stale cache before scanning")
+
+    pages_p = subparsers.add_parser("pages", parents=[parent_parser], help="Export static interactive graph and report artifacts")
+    pages_p.add_argument("project", nargs="?", default=".", help="Project path")
+    pages_p.add_argument("--out", default="dist", help="Output directory for static artifacts (default: dist)")
+    pages_p.add_argument("--entry", action="append", help="Explicit application entry point(s)")
+    pages_p.add_argument("--clean-cache", action="store_true", help="Clear stale cache before exporting")
 
     serve_p = subparsers.add_parser("serve", parents=[parent_parser], help="Start localhost web UI server")
     serve_p.add_argument("project", nargs="?", default=".", help="Project path")
     serve_p.add_argument("--entry", action="append", help="Explicit application entry point(s)")
+    serve_p.add_argument("--host", default="127.0.0.1", help="Host interface to bind to (e.g. 127.0.0.1 or 0.0.0.0)")
     serve_p.add_argument("--port", type=int, default=3000, help="Port number")
 
     trace_p = subparsers.add_parser("trace", parents=[parent_parser], help="Trace symbol logic")
@@ -266,15 +336,16 @@ def main(args: Optional[List[str]] = None) -> int:
     parsed = parser.parse_args(args)
 
     if parsed.command == "init":
-        Path(".codeui").mkdir(exist_ok=True)
+        p = Path(parsed.project).resolve()
+        (p / ".codeui").mkdir(parents=True, exist_ok=True)
         if parsed.json:
-            print(json.dumps({"status": "initialized", "dir": ".codeui"}))
+            print(json.dumps({"status": "initialized", "dir": str(p / ".codeui")}))
         else:
-            print("Initialized .codeui workspace directory")
+            print(f"Initialized .codeui workspace directory in {p}")
         return 0
     elif parsed.command == "scan":
         p = Path(parsed.project).resolve()
-        g = scan_project(p, entry_points=parsed.entry)
+        g = scan_project(p, entry_points=parsed.entry, clean_cache=parsed.clean_cache)
         out_dir = Path(parsed.out)
         out_dir.mkdir(parents=True, exist_ok=True)
         (out_dir / "graph.json").write_text(JSONEmitter().emit(g), encoding="utf-8")
@@ -283,12 +354,35 @@ def main(args: Optional[List[str]] = None) -> int:
         else:
             print(f"Scanned {len(g.get_all_files())} files, {len(g.get_all_symbols())} symbols, {len(g.get_findings())} defects.")
         return 0
+    elif parsed.command == "pages":
+        out_path = export_pages(
+            project_path=parsed.project,
+            out_dir=parsed.out,
+            entry_points=parsed.entry,
+            clean_cache=parsed.clean_cache,
+        )
+        if parsed.json:
+            print(json.dumps({"status": "exported", "out_dir": str(out_path)}))
+        else:
+            print(f"Exported static graph and report artifacts to '{out_path}'.")
+        return 0
     elif parsed.command == "serve":
         p = Path(parsed.project).resolve()
         g = scan_project(p, entry_points=parsed.entry)
         store = OverrideStore()
-        server = create_server(g, store, p, port=parsed.port, rescan_fn=scan_project, entry_points=parsed.entry)
-        print(f"codeui UI server running on http://127.0.0.1:{parsed.port}")
+        try:
+            server = create_server(g, store, p, host=parsed.host, port=parsed.port, rescan_fn=scan_project, entry_points=parsed.entry)
+        except OSError as e:
+            if "already in use" in str(e).lower() or getattr(e, "errno", 0) == 98:
+                try:
+                    import subprocess
+                    subprocess.run(["fuser", "-k", f"{parsed.port}/tcp"], capture_output=True)
+                except Exception:
+                    pass
+                server = create_server(g, store, p, host=parsed.host, port=parsed.port, rescan_fn=scan_project, entry_points=parsed.entry)
+            else:
+                raise
+        print(f"codeui UI server running on http://{parsed.host}:{parsed.port}")
         try:
             server.serve_forever()
         except KeyboardInterrupt:

codeui/core/cache.py

@@ -115,6 +115,37 @@ class AnalysisCache:
             result.append(sym)
         return result
 
+    def clear(self) -> None:
+        """Clear all entries from the cache database.
+        Example:
+            >>> cache = AnalysisCache(Path(".codeui/test_cache.db"))
+            >>> cache.clear()
+            >>> cache.close()
+        """
+        with self.conn:
+            self.conn.execute("DELETE FROM file_cache")
+
+    def prune_stale(self, existing_file_paths: Any) -> int:
+        """Remove cached entries for files that no longer exist on disk.
+        Example:
+            >>> cache = AnalysisCache(Path(".codeui/test_cache.db"))
+            >>> cache.prune_stale(["a.py"])
+            0
+            >>> cache.close()
+        """
+        valid_set = set(existing_file_paths)
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT file_path FROM file_cache")
+        cached_paths = [row[0] for row in cursor.fetchall()]
+        stale_paths = [p for p in cached_paths if p not in valid_set]
+        if stale_paths:
+            with self.conn:
+                self.conn.executemany(
+                    "DELETE FROM file_cache WHERE file_path = ?",
+                    [(p,) for p in stale_paths],
+                )
+        return len(stale_paths)
+
     def close(self) -> None:
         """Close SQLite database connection.
         Example:
@@ -133,3 +164,26 @@ def compute_content_hash(content: str) -> str:
         64
     """
     return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+def remove_stale_cache(cache_path: Path) -> bool:
+    """Dynamically remove stale cache file or directory.
+    Example:
+        >>> p = Path(".codeui/stale_test.db")
+        >>> remove_stale_cache(p)
+        False
+    """
+    path = Path(cache_path)
+    if path.is_file():
+        try:
+            path.unlink(missing_ok=True)
+            return True
+        except OSError:
+            return False
+    if path.is_dir():
+        import shutil
+        try:
+            shutil.rmtree(path, ignore_errors=True)
+            return True
+        except OSError:
+            return False
+    return False