codebread 1.1.0__tar.gz → 1.1.3__tar.gz

{codebread-1.1.0 → codebread-1.1.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: codebread
-Version: 1.1.0
+Version: 1.1.3
 Summary: Interactive codebase analyzer & visualizer — slice open a project and see how it's wired together.
 Author: Danial Irsyad
 License: MIT
-Keywords: codebase,analyzer,visualizer,call-graph,architecture
+Keywords: codebase,analyzer,visualizer,call-graph,architecture,dependency-graph,code-visualization,static-analysis,code-map
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -23,6 +23,11 @@ Dynamic: license-file
   Files, functions, API routes and database tables, mapped in your browser.
 </p>
 
+<p align="center">
+  An interactive codebase visualizer: call graph, dependency map and API-to-database tracing<br>
+  for Python, JavaScript, TypeScript, PHP, Java, Go, C# and Ruby.
+</p>
+
 <p align="center">
   <a href="https://pypi.org/project/codebread/"><img alt="PyPI" src="https://img.shields.io/pypi/v/codebread?color=b0541c&label=pypi"></a>
   <a href="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml/badge.svg"></a>

{codebread-1.1.0 → codebread-1.1.3}/README.md

@@ -7,6 +7,11 @@
   Files, functions, API routes and database tables, mapped in your browser.
 </p>
 
+<p align="center">
+  An interactive codebase visualizer: call graph, dependency map and API-to-database tracing<br>
+  for Python, JavaScript, TypeScript, PHP, Java, Go, C# and Ruby.
+</p>
+
 <p align="center">
   <a href="https://pypi.org/project/codebread/"><img alt="PyPI" src="https://img.shields.io/pypi/v/codebread?color=b0541c&label=pypi"></a>
   <a href="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml/badge.svg"></a>

{codebread-1.1.0 → codebread-1.1.3}/codebread/connections.py

@@ -26,6 +26,16 @@ COMMON_NAMES = {  # never resolve these across files by name alone
 ENTRY_NAMES = {
     "main", "__init__", "__main__", "__new__", "__call__", "setup", "setUp",
     "tearDown", "run", "handler", "index", "render", "constructor",
+    # PHP magic methods
+    "__construct", "__destruct", "__invoke", "__get", "__set", "__toString",
+    # Laravel: migrations, providers, jobs, requests, factories, policies
+    "up", "down", "boot", "booted", "register", "handle", "schedule", "rules",
+    "authorize", "definition", "casts", "toArray", "via", "toMail", "broadcastOn",
+    "store", "show", "create", "edit", "update", "destroy",
+    # Filament / Livewire hooks
+    "form", "table", "configure", "panel", "mount", "getPages", "getRelations",
+    "getHeaderActions", "getStats", "getData", "getType", "getEloquentQuery",
+    "getGloballySearchableAttributes", "canAccessPanel",
 }
 
 
@@ -80,6 +90,10 @@ def _resolve_file_ref(base_file: str, target: str, file_set) -> Optional[str]:
         posixpath.normpath(target.lstrip("/")),
         target.lstrip("./"),
     ]
+    # PSR-4 namespaces: `use App\Support\MjIcon` lives in app/Support/MjIcon.php
+    head, _, rest = target.partition("/")
+    if rest and head[:1].isupper():
+        candidates.append(head.lower() + "/" + rest)
     # python dotted modules: models / app.utils -> models.py / app/utils.py
     if "/" not in target and "." not in posixpath.basename(target):
         candidates.append(target.replace(".", "/"))
@@ -233,8 +247,9 @@ def build_graph(files: List[FileInfo], tree: Dict,
             if t is not None:  # enrich a placeholder with real definition
                 for n in nodes:
                     if n["id"] == nid:
-                        if t.fields:
-                            n["fields"] = t.fields
+                        if t.fields:  # merge: migrations add columns over time
+                            n["fields"] = n.get("fields", []) + [
+                                c for c in t.fields if c not in n.get("fields", [])]
                         if t.model:
                             n["model"] = t.model
                         if t.source:
@@ -252,11 +267,17 @@ def build_graph(files: List[FileInfo], tree: Dict,
         })
         return nid
 
+    # real definitions first, so a model's guessed name can snap to one
+    defined = {t.name.lower() for f in files for t in f.tables if not t.aliases}
     for f in files:
-        for t in f.tables:
+        for t in sorted(f.tables, key=lambda t: bool(t.aliases)):
+            if t.aliases:
+                t.name = next((a for a in t.aliases if a.lower() in defined), t.name)
             nid = table_node(t.name, t)
             if t.model:
                 model_to_table[t.model.lower()] = nid
+                if t.aliases:  # Eloquent model file -> its table
+                    add_edge(f.path, nid, "db", f"{t.model} model → {t.name}")
 
     # ---- call edges --------------------------------------------------
     for f in files:
@@ -288,12 +309,14 @@ def build_graph(files: List[FileInfo], tree: Dict,
 
     # ---- file-level connections ---------------------------------------
     file_set = {f.path for f in files}
+    called_from_page: set = set()  # own functions a page calls (onclick="f()")
     for f in files:
         fname = f.path.split("/")[-1]
         local = {fn.name: fn_nodes[(f.path, fn.name)] for fn in f.functions}
         # top-level calls: page/script code calling into functions
         for callee in f.calls:
             if callee in local:
+                called_from_page.add(local[callee])
                 continue  # a file already implicitly contains its own fns
             candidates = name_index.get(callee, [])
             if not candidates or callee in COMMON_NAMES:
@@ -332,13 +355,13 @@ def build_graph(files: List[FileInfo], tree: Dict,
             target = handler_id or f.path
             route_index.append((r.method, _norm_path(r.path), target,
                                 f"{r.method} {r.path}"))
-            if handler_id:
-                # mark handler node with its route
-                for n in nodes:
-                    if n["id"] == handler_id:
-                        n.setdefault("routes", []).append(
-                            {"method": r.method, "path": r.path})
-                        break
+            # mark the handler with its route; closure routes (Laravel
+            # `Route::get('/', function () {...})`) land on the file itself
+            for n in nodes:
+                if n["id"] == target:
+                    n.setdefault("routes", []).append(
+                        {"method": r.method, "path": r.path})
+                    break
 
     # ---- api edges (frontend call -> backend route) -------------------
     def match_route(method: str, url: str) -> Optional[Tuple[str, str]]:
@@ -374,6 +397,8 @@ def build_graph(files: List[FileInfo], tree: Dict,
                 tid = model_to_table.get(ref.table.lower()) \
                     or table_ids.get(ref.table.lower())
                 if tid is None:
+                    if ref.via == "orm-guess":
+                        continue  # `Foo::where()` where Foo isn't a known model
                     # unknown table: create it only for confident refs
                     if ref.via == "sql" or ref.table.lower() in table_ids:
                         tid = table_node(ref.table)
@@ -389,6 +414,12 @@ def build_graph(files: List[FileInfo], tree: Dict,
 
     # ---- orphans + circular dependencies --------------------------------
     cycles = _mark_orphans_and_cycles(nodes, edges)
+    # Eloquent model methods (relations, accessors) are reached through magic
+    # properties like $booking->user, which static analysis can't see
+    model_files = {f.path for f in files for t in f.tables if t.model and t.aliases}
+    for n in nodes:
+        if n.get("orphan") and (n.get("file") in model_files or n["id"] in called_from_page):
+            del n["orphan"]
 
     # ---- stats ---------------------------------------------------------
     n_fns = sum(1 for n in nodes if n["kind"] in ("function", "method"))

{codebread-1.1.0 → codebread-1.1.3}/codebread/context.py

@@ -8,6 +8,7 @@ it once, then opens only the files that matter for the task.
 from __future__ import annotations
 
 import os
+import re
 from collections import Counter, defaultdict
 from typing import Dict, Iterable
 
@@ -24,6 +25,20 @@ def _short(items: Iterable[str], cap: int = LIST_CAP) -> str:
     return ", ".join(items[:cap]) + more
 
 
+def _human(name: str) -> str:
+    return " ".join(re.sub(r"(?<=[a-z0-9])(?=[A-Z])|_+", " ", name).split()).lower()
+
+
+def _desc(fn: Dict) -> str:
+    """Drop auto-descriptions that only repeat the name ("Get Header Actions."),
+    keep what they add after it ("handles POST /users; queries users")."""
+    d = (fn.get("description") or "").strip()
+    head, _, tail = d.partition(" — ")
+    if head.rstrip(".").lower() == _human(fn["label"]):
+        return tail.rstrip(".")
+    return d
+
+
 def to_markdown(graph: Dict) -> str:
     nodes = {n["id"]: n for n in graph.get("nodes", [])}
     edges = [e for e in graph.get("edges", [])
@@ -76,11 +91,16 @@ def to_markdown(graph: Dict) -> str:
           ""]
 
     # ---- entry points
-    routes = sorted(((r["method"], r["path"], fn) for fl in fns.values() for fn in fl
-                     for r in fn.get("routes") or []), key=lambda x: (x[1], x[0]))
+    routes = set()
+    for n in nodes.values():
+        for r in n.get("routes") or []:
+            if n["kind"] == "file":  # inline handler, e.g. a Laravel route closure
+                routes.add((r["method"], r["path"], f"`{n['file']}` (inline)"))
+            elif n["kind"] in ("function", "method"):
+                routes.add((r["method"], r["path"], f"`{n['file']}:{n['label']}()`"))
     if routes:
         L += ["## HTTP routes", "", "| Method | Path | Handler |", "|---|---|---|"]
-        L += [f"| {m} | `{p}` | `{fn['file']}:{fn['label']}()` |" for m, p, fn in routes]
+        L += [f"| {m} | `{p}` | {h} |" for m, p, h in sorted(routes, key=lambda x: (x[1], x[0], x[2]))]
         L.append("")
 
     # ---- data model
@@ -106,6 +126,7 @@ def to_markdown(graph: Dict) -> str:
         by_layer[f.get("layer") or "unknown"].append(f)
     for layer in sorted(by_layer, key=layer_rank):
         L += [f"### {LAYER_NAME.get(layer, layer)}", ""]
+        quiet = []  # files with nothing to say beyond their name
         for f in by_layer[layer]:
             path = f["file"]
             members = [f["id"]] + [fn["id"] for fn in fns.get(path, [])]
@@ -113,6 +134,9 @@ def to_markdown(graph: Dict) -> str:
                      if owner(e["target"]) != f["id"]]
             heard = [ref(owner(e["source"])) for m in members for e in in_e[m]
                      if owner(e["source"]) != f["id"]]
+            if not (talks or heard or fns.get(path) or f.get("warnings")):
+                quiet.append(f"`{path}`")
+                continue
             L.append(f"#### `{path}` ({f.get('language', '?')}, {f.get('loc', 0)} lines)")
             if talks:
                 L.append("Uses: " + _short(talks))
@@ -125,28 +149,30 @@ def to_markdown(graph: Dict) -> str:
                 params = ", ".join(fn.get("params") or [])
                 cls = f"{fn['parentClass']}." if fn.get("parentClass") else ""
                 line = f"- `{cls}{fn['label']}({params})` L{fn.get('line', '?')}"
-                if fn.get("description"):
-                    line += f": {fn['description']}"
+                if _desc(fn):
+                    line += f": {_desc(fn)}"
                 calls = [ref(e["target"], path) for e in out_e[fn["id"]] if e["kind"] != "db"]
                 tbls = [nodes[e["target"]]["label"] for e in out_e[fn["id"]] if e["kind"] == "db"]
                 callers = [ref(e["source"], path) for e in in_e[fn["id"]]]
                 extra = []
                 if calls:
                     extra.append("calls " + _short(calls))
-                if tbls and not fn.get("description"):  # descriptions already name their tables
+                if tbls and not all(t in _desc(fn) for t in tbls):  # skip if the description names them
                     extra.append("tables " + _short(tbls))
                 if callers:
                     extra.append("called by " + _short(callers))
                 if fn.get("cycle"):
                     extra.append("in a call cycle")
-                elif fn.get("orphan"):
-                    extra.append("no callers found")
+                # no "no callers found": framework hooks (up(), boot(), form())
+                # are called by the framework, so it would mislead more than help
                 if extra:
                     line += " | " + "; ".join(extra)
                 L.append(line)
             if len(fl) > FNS_PER_FILE:
                 L.append(f"- … {len(fl) - FNS_PER_FILE} more functions")
             L.append("")
+        if quiet:
+            L += ["Other files: " + _short(quiet, 40), ""]
 
     # ---- things to be careful about
     notes = []

{codebread-1.1.0 → codebread-1.1.3}/codebread/models.py

@@ -58,6 +58,9 @@ class TableInfo:
     fields: List[str] = field(default_factory=list)
     line: int = 0
     source: str = ""     # file that defines it
+    # candidate names when `name` is only a guess (e.g. Laravel's pluralised
+    # Eloquent table names); resolved against real tables in build_graph
+    aliases: List[str] = field(default_factory=list)
 
 
 @dataclass

{codebread-1.1.0 → codebread-1.1.3}/codebread/parsers/generic_parser.py

@@ -15,6 +15,7 @@ KEYWORDS = {
     "try", "throw", "case", "using", "lock", "foreach", "select", "func",
     "defer", "go", "range", "elsif", "unless", "until", "when", "match",
     "sizeof", "typeof", "yield", "puts", "print", "println", "printf",
+    "function", "fn", "use",  # PHP closures: `function () use ($x)`, `fn () =>`
 }
 
 SQL_RE = re.compile(
@@ -23,6 +24,100 @@ SQL_RE = re.compile(
     re.IGNORECASE)
 CALL_RE = re.compile(r"(?<![\w$.:])([A-Za-z_][\w]*)\s*\(")
 
+# ---- PHP / Laravel ------------------------------------------------------
+# CALL_RE skips `X::f(` and would read `$obj->label(` as a call to any
+# function named label. In PHP only these member calls are trustworthy:
+PHP_MEMBER_CALL_RE = re.compile(
+    r"(?:\$this->|\b(?:self|static|parent)::|\b[A-Z]\w*::)(\w+)\s*\(")
+PHP_USE_RE = re.compile(r"^\s*use\s+([A-Za-z_][\w\\]*\\\w+)\s*(?:as\s+\w+\s*)?;",
+                        re.MULTILINE)
+PHP_VIEW_RE = re.compile(r"\bview\s*\(\s*['\"]([\w.\-/]+)['\"]")
+# Eloquent: Booking::where(...), Booking::create(...), DB::table('bookings')
+PHP_ORM_RE = re.compile(
+    r"\b([A-Z]\w*)::(query|where\w*|find\w*|first\w*|create|insert\w*|"
+    r"update\w*|upsert|destroy|all|with|latest|oldest|orderBy|count|sum|"
+    r"pluck|paginate|select)\s*\(")
+PHP_DB_TABLE_RE = re.compile(r"\bDB::table\(\s*['\"](\w+)['\"]")
+ORM_OP = {"create": "insert", "insert": "insert", "upsert": "insert",
+          "update": "update", "destroy": "delete"}
+NOT_MODELS = {"DB", "Route", "Schema", "Carbon", "Str", "Arr", "Auth", "Cache",
+              "Log", "Http", "Storage", "Validator", "Hash", "Session", "Config",
+              "Gate", "Mail", "Event", "Queue", "App", "Request", "Response"}
+SCHEMA_RE = re.compile(r"Schema::(create|table)\s*\(\s*['\"](\w+)['\"]")
+BLUEPRINT_COL_RE = re.compile(r"\$\w+->(\w+)\s*\(\s*(?:['\"](\w+)['\"])?")
+BLUEPRINT_IMPLIED = {"id": ["id"], "timestamps": ["created_at", "updated_at"],
+                     "timestampsTz": ["created_at", "updated_at"],
+                     "softDeletes": ["deleted_at"], "rememberToken": ["remember_token"]}
+BLUEPRINT_SKIP = {"index", "unique", "primary", "foreign", "dropColumn",
+                  "dropForeign", "dropIndex", "renameColumn", "fullText",
+                  "spatialIndex", "comment", "engine", "charset", "collation"}
+ELOQUENT_RE = re.compile(
+    r"^\s*(?:final\s+)?class\s+(\w+)\s+extends\s+(?:Model|Authenticatable|Pivot)\b",
+    re.MULTILINE)
+PHP_TABLE_PROP_RE = re.compile(r"\$table\s*=\s*['\"](\w+)['\"]")
+
+
+def _snake(name: str) -> str:
+    return re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name).lower()
+
+
+def _plural_candidates(snake: str) -> List[str]:
+    """Laravel's table guess for a model, best first (Booking -> bookings)."""
+    if snake.endswith("y") and snake[-2:-1] not in "aeiou":
+        first = snake[:-1] + "ies"
+    elif snake.endswith(("s", "x", "z", "ch", "sh")):
+        first = snake + "es"
+    else:
+        first = snake + "s"
+    return [first, snake]  # bare name covers uncountables like `equipment`
+
+
+def _php_member_calls(body: str) -> List[str]:
+    return [m.group(1) for m in PHP_MEMBER_CALL_RE.finditer(body)]
+
+
+def _php_db_refs(body: str, line: int) -> List[DbRef]:
+    refs = [DbRef(table=m.group(1), op="query", via="sql", line=line)
+            for m in PHP_DB_TABLE_RE.finditer(body)]
+    for m in PHP_ORM_RE.finditer(body):
+        if m.group(1) in NOT_MODELS:
+            continue
+        op = next((v for k, v in ORM_OP.items() if m.group(2).startswith(k)), "select")
+        refs.append(DbRef(table=m.group(1), op=op, via="orm-guess", line=line))
+    return refs
+
+
+def parse_laravel(info: FileInfo, text: str) -> None:
+    """File-level Laravel facts: `use` imports, view() links, migrations,
+    Eloquent models. Cheap regex passes; nothing matches in non-Laravel PHP."""
+    info.imports.extend(m.group(1).replace("\\", "/") for m in PHP_USE_RE.finditer(text))
+    for m in PHP_VIEW_RE.finditer(text):
+        info.links.append("resources/views/" + m.group(1).replace(".", "/") + ".blade.php")
+
+    for m in SCHEMA_RE.finditer(text):
+        end = _brace_end_line(text, m.end())
+        block = "\n".join(text.split("\n")[_line_of(text, m.start()) - 1:end or None])
+        cols: List[str] = []
+        for c in BLUEPRINT_COL_RE.finditer(block):
+            method, col = c.group(1), c.group(2)
+            if method in BLUEPRINT_SKIP:
+                continue
+            for name in BLUEPRINT_IMPLIED.get(method, [col] if col else []):
+                if name not in cols:
+                    cols.append(name)
+        # Schema::table() only alters: it adds columns but doesn't define the table
+        info.tables.append(TableInfo(name=m.group(2), fields=cols[:40],
+                                     line=_line_of(text, m.start()),
+                                     source=info.path if m.group(1) == "create" else ""))
+
+    for m in ELOQUENT_RE.finditer(text):
+        cls = m.group(1)
+        explicit = PHP_TABLE_PROP_RE.search(text)
+        cands = [explicit.group(1)] if explicit else _plural_candidates(_snake(cls))
+        # no source: the migration defines the table; the model links to it by edge
+        info.tables.append(TableInfo(name=cands[0], model=cls, aliases=cands,
+                                     line=_line_of(text, m.start())))
+
 LANG_PATTERNS: Dict[str, Dict[str, Pattern]] = {
     "go": {
         "function": re.compile(
@@ -173,8 +268,16 @@ def parse_generic(info: FileInfo, text: str, language: str) -> None:
             cname = cm.group(1)
             if cname in KEYWORDS or cname == name or cname in seen:
                 continue
+            if language == "php" and body[max(0, cm.start() - 2):cm.start()] == "->":
+                continue  # $obj->method(): unknown receiver, see PHP_MEMBER_CALL_RE
             seen.add(cname)
             fn.calls.append(cname)
+        if language == "php":
+            for cname in _php_member_calls(body):
+                if cname not in seen and cname != name and cname not in KEYWORDS:
+                    seen.add(cname)
+                    fn.calls.append(cname)
+            fn.db_refs.extend(_php_db_refs(body, start_line))
         fn.calls = fn.calls[:40]
         fn.description = describe(fn, body[:400])
         info.functions.append(fn)
@@ -196,6 +299,10 @@ def parse_generic(info: FileInfo, text: str, language: str) -> None:
 
     if language in ("php", "ruby"):
         extract_toplevel(info, text)
+    if language == "php":
+        parse_laravel(info, text)
+        info.imports = sorted(set(info.imports))[:60]
+        info.links = list(dict.fromkeys(info.links))[:30]
 
 
 PAGE_LINK_RE = re.compile(
@@ -218,14 +325,23 @@ def extract_toplevel(info: FileInfo, text: str) -> None:
     def outside(line: int) -> bool:
         return not any(s <= line <= e for s, e in fn_ranges)
 
+    is_php = info.language == "php"
     seen = set()
     for m in CALL_RE.finditer(text):
         name = m.group(1)
         if name in TOPLEVEL_NOISE or name in seen:
             continue
+        if is_php and text[max(0, m.start() - 2):m.start()] == "->":
+            continue
         if outside(_line_of(text, m.start())):
             seen.add(name)
             info.calls.append(name)
+    if is_php:  # routes/web.php closures call App\X::y() at top level
+        for m in PHP_MEMBER_CALL_RE.finditer(text):
+            name = m.group(1)
+            if name not in seen and name not in TOPLEVEL_NOISE and outside(_line_of(text, m.start())):
+                seen.add(name)
+                info.calls.append(name)
     info.calls = info.calls[:40]
 
     seen_l = set()

{codebread-1.1.0 → codebread-1.1.3}/codebread/scanner.py

@@ -85,32 +85,45 @@ class _SimpleGitignore:
 
 
 class GitignoreStack:
-    """Loads the root .gitignore (via pathspec when available)."""
+    """Every .gitignore in the tree, each scoped to its own folder — like git.
+
+    Frameworks lean on nested ones (Laravel's storage/framework/views/.gitignore
+    is just `*` + `!.gitignore`), so reading only the root file lets compiled
+    caches flood the scan. Uses pathspec when available.
+    """
 
     def __init__(self, root: str):
         self.root = root
-        self._spec = None
-        self._simple: Optional[_SimpleGitignore] = None
-        gi = os.path.join(root, ".gitignore")
-        if os.path.isfile(gi):
-            try:
-                with open(gi, "r", encoding="utf-8", errors="replace") as f:
-                    lines = f.readlines()
-            except OSError:
-                lines = []
-            try:
-                import pathspec  # type: ignore
-                self._spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
-            except ImportError:
-                self._simple = _SimpleGitignore(lines)
+        self._rules: List[Tuple[str, object]] = []  # (folder rel to root, matcher)
+        self.load_dir(root, "")
+
+    def load_dir(self, abs_dir: str, rel_dir: str) -> None:
+        gi = os.path.join(abs_dir, ".gitignore")
+        if not os.path.isfile(gi):
+            return
+        try:
+            with open(gi, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+        except OSError:
+            return
+        try:
+            import pathspec  # type: ignore
+            matcher: object = pathspec.GitIgnoreSpec.from_lines(lines)
+        except ImportError:
+            matcher = _SimpleGitignore(lines)
+        self._rules.append((rel_dir.replace(os.sep, "/").strip("/"), matcher))
 
     def ignored(self, rel_path: str, is_dir: bool) -> bool:
         rel = rel_path.replace(os.sep, "/")
-        if self._spec is not None:
-            probe = rel + "/" if is_dir else rel
-            return self._spec.match_file(probe)
-        if self._simple is not None:
-            return self._simple.matches(rel, is_dir)
+        for base, m in self._rules:
+            if base and not rel.startswith(base + "/"):
+                continue
+            sub = rel[len(base) + 1:] if base else rel
+            if isinstance(m, _SimpleGitignore):
+                if m.matches(sub, is_dir):
+                    return True
+            elif m.match_file(sub + "/" if is_dir else sub):
+                return True
         return False
 
 
@@ -157,6 +170,7 @@ def scan(root: str, max_file_kb: int = 1024) -> Dict:
                     continue
                 if gitignore.ignored(rel, True):
                     continue
+                gitignore.load_dir(entry.path, rel)
                 child = walk_dir(entry.path, rel)
                 # keep dirs that contain anything (incl. warning stubs)
                 if child["children"] or child.get("warning"):

{codebread-1.1.0 → codebread-1.1.3}/codebread.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: codebread
-Version: 1.1.0
+Version: 1.1.3
 Summary: Interactive codebase analyzer & visualizer — slice open a project and see how it's wired together.
 Author: Danial Irsyad
 License: MIT
-Keywords: codebase,analyzer,visualizer,call-graph,architecture
+Keywords: codebase,analyzer,visualizer,call-graph,architecture,dependency-graph,code-visualization,static-analysis,code-map
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -23,6 +23,11 @@ Dynamic: license-file
   Files, functions, API routes and database tables, mapped in your browser.
 </p>
 
+<p align="center">
+  An interactive codebase visualizer: call graph, dependency map and API-to-database tracing<br>
+  for Python, JavaScript, TypeScript, PHP, Java, Go, C# and Ruby.
+</p>
+
 <p align="center">
   <a href="https://pypi.org/project/codebread/"><img alt="PyPI" src="https://img.shields.io/pypi/v/codebread?color=b0541c&label=pypi"></a>
   <a href="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/honow48-tech/CodeBread/actions/workflows/ci.yml/badge.svg"></a>

{codebread-1.1.0 → codebread-1.1.3}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codebread"
-version = "1.1.0"
+version = "1.1.3"
 description = "Interactive codebase analyzer & visualizer — slice open a project and see how it's wired together."
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
 authors = [{ name = "Danial Irsyad" }]
-keywords = ["codebase", "analyzer", "visualizer", "call-graph", "architecture"]
+keywords = ["codebase", "analyzer", "visualizer", "call-graph", "architecture",
+            "dependency-graph", "code-visualization", "static-analysis", "code-map"]
 dependencies = []
 
 [project.optional-dependencies]

{codebread-1.1.0 → codebread-1.1.3}/tests/test_generic_parser.py

@@ -102,3 +102,65 @@ def test_redact_secrets_preserves_line_count():
     text = "A=1\nB=2\nPASSWORD=x\nC=3\n"
     out = redact_secrets(text)
     assert len(out.splitlines()) == len(text.splitlines())
+
+
+def test_laravel_migrations_models_routes_and_calls():
+    from codebread.connections import build_graph
+
+    def php(path, src):
+        info = FileInfo(path=path, language="php")
+        parse_generic(info, src, "php")
+        return info
+
+    files = [
+        php("database/migrations/1_create_bookings.php", """<?php
+return new class extends Migration { public function up(): void {
+    Schema::create('bookings', function (Blueprint $table) {
+        $table->id(); $table->string('reference'); $table->timestamps();
+    });
+    Schema::create('equipment', function (Blueprint $table) { $table->id(); });
+} };"""),
+        php("database/migrations/2_add_status.php", """<?php
+return new class extends Migration { public function up(): void {
+    Schema::table('bookings', function (Blueprint $table) { $table->string('status'); });
+} };"""),
+        php("app/Models/Booking.php", "<?php\nclass Booking extends Model {\n"
+            "    public function user() { return $this->belongsTo(User::class); }\n}\n"),
+        php("app/Models/Equipment.php", "<?php\nclass Equipment extends Model {}\n"),
+        php("app/Support/Icons.php", "<?php\nclass Icons { public static function label($k) { return $k; } }\n"),
+        php("app/Widgets/Stats.php", r"""<?php
+use App\Support\Icons;
+class Stats { public function table($t) {
+    return $t->label('Total')->value(Booking::where('status', 'x')->count());
+} }"""),
+        php("routes/web.php", """<?php
+Route::get('/', function () { return view('welcome'); });
+Route::get('/icons', function () { return Icons::label('x'); });"""),
+        FileInfo(path="resources/views/welcome.blade.php", language="php"),
+    ]
+    g = build_graph(files, {"type": "dir", "children": []}, [])
+    nodes = {n["id"]: n for n in g["nodes"]}
+    edges = {(e["source"], e["target"], e["kind"]) for e in g["edges"]}
+
+    # migrations define tables; an alter adds columns without stealing the source
+    assert nodes["table::bookings"]["fields"] == ["id", "reference", "created_at",
+                                                 "updated_at", "status"]
+    assert nodes["table::bookings"]["file"] == "database/migrations/1_create_bookings.php"
+    # models snap to the real table: Booking -> bookings, Equipment -> equipment
+    assert nodes["table::bookings"]["model"] == "Booking"
+    assert nodes["table::equipment"]["model"] == "Equipment"
+    assert "table::equipments" not in nodes
+    # closure routes land on the routes file; view() links to the Blade file
+    assert {r["path"] for r in nodes["routes/web.php"]["routes"]} == {"/", "/icons"}
+    assert ("routes/web.php", "resources/views/welcome.blade.php", "link") in edges
+    # static calls count, $obj->label() does not; Eloquent calls reach the table
+    label = "app/Support/Icons.php::label@2"
+    assert ("routes/web.php", label, "call") in edges
+    assert not any(s.startswith("app/Widgets/Stats.php") and t == label for s, t, _ in edges)
+    assert ("app/Widgets/Stats.php::table@3", "table::bookings", "db") in edges
+    # `use App\...` resolves to the file (PSR-4)
+    assert ("app/Widgets/Stats.php", "app/Support/Icons.php", "include") in edges
+    # framework-called code isn't "unused": migration hooks, Eloquent relations
+    by_label = {(n.get("file"), n["label"]): n for n in g["nodes"]}
+    assert not by_label[("database/migrations/1_create_bookings.php", "up")].get("orphan")
+    assert not by_label[("app/Models/Booking.php", "user")].get("orphan")

{codebread-1.1.0 → codebread-1.1.3}/tests/test_scanner.py

@@ -82,3 +82,15 @@ def test_looks_binary_false_for_text(tmp_path):
     p = tmp_path / "note.unknownext"
     p.write_text("just plain text", encoding="utf-8")
     assert looks_binary(str(p)) is False
+
+
+def test_scan_respects_nested_gitignore(tmp_path):
+    # Laravel ships storage/framework/views/.gitignore = "*\n!.gitignore":
+    # compiled Blade caches must not leak into the scan
+    root = str(tmp_path)
+    _write(root, "app/keep.php", "<?php function f() {}\n")
+    _write(root, "storage/framework/views/.gitignore", "*\n!.gitignore\n")
+    _write(root, "storage/framework/views/0a1b2c.php", "<?php echo 1;\n")
+    paths = {f["path"] for f in scan(root)["files"]}
+    assert "app/keep.php" in paths
+    assert "storage/framework/views/0a1b2c.php" not in paths