entrygraph 0.1.3__tar.gz → 0.1.5__tar.gz

{entrygraph-0.1.3 → entrygraph-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.3
+Version: 0.1.5
 Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
 Project-URL: Repository, https://github.com/brettbergin/entrygraph
 Author-email: Brett Bergin <brettberginbc@yahoo.com>

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.3'
-__version_tuple__ = version_tuple = (0, 1, 3)
+__version__ = version = '0.1.5'
+__version_tuple__ = version_tuple = (0, 1, 5)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/detect/entrypoints/python.py

@@ -7,6 +7,7 @@ import re
 
 from entrygraph.detect.entrypoints.base import (
     EntrypointRule,
+    Matcher,
     first_string_arg,
     identifier_args,
     methods_kwarg,
@@ -157,20 +158,30 @@ def _django_urls(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
-def _click_commands(x: FileExtraction) -> list[EntrypointHint]:
-    hints = []
-    for symbol, decorator in _decorated(x):
-        if _CLICK_CMD.match(decorator):
-            hints.append(
-                EntrypointHint(
-                    rule_id="python.click.command",
-                    kind=EntrypointKind.CLI_COMMAND,
-                    handler_qualified_name=symbol.qualified_name,
-                    name=first_string_arg(decorator) or symbol.name,
-                    framework="click",
+def _click_like(framework: str, rule_id: str) -> Matcher:
+    """click and typer share decorator shape (`@app.command`); only the
+    reported framework/rule_id differ, so bind them per rule."""
+
+    def _match(x: FileExtraction) -> list[EntrypointHint]:
+        hints = []
+        for symbol, decorator in _decorated(x):
+            if _CLICK_CMD.match(decorator):
+                hints.append(
+                    EntrypointHint(
+                        rule_id=rule_id,
+                        kind=EntrypointKind.CLI_COMMAND,
+                        handler_qualified_name=symbol.qualified_name,
+                        name=first_string_arg(decorator) or symbol.name,
+                        framework=framework,
+                    )
                 )
-            )
-    return hints
+        return hints
+
+    return _match
+
+
+_click_commands = _click_like("click", "python.click.command")
+_typer_commands = _click_like("typer", "python.typer.command")
 
 
 def _celery_tasks(x: FileExtraction) -> list[EntrypointHint]:
@@ -363,7 +374,7 @@ register(
 )
 register(
     EntrypointRule(
-        "python.typer.command", "python", "typer", EntrypointKind.CLI_COMMAND, _click_commands
+        "python.typer.command", "python", "typer", EntrypointKind.CLI_COMMAND, _typer_commands
     )
 )
 register(

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/detect/frameworks.py

@@ -104,6 +104,16 @@ FRAMEWORKS: list[FrameworkSpec] = [
         ),
     ),
     # JS/TS, Go, Java, Ruby specs land with their extractors (M8)
+    FrameworkSpec(
+        "aws-lambda-js",
+        "javascript",
+        (
+            FrameworkSignal("file_presence", "serverless.y*ml", 0.5),
+            FrameworkSignal("file_presence", "template.y*ml", 0.3),
+            FrameworkSignal("manifest_dep", "@types/aws-lambda", 0.6),
+            FrameworkSignal("manifest_dep", "aws-lambda", 0.5),
+        ),
+    ),
     FrameworkSpec(
         "express",
         "javascript",

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/detect/manifests.py

@@ -223,9 +223,11 @@ def parse_manifests(root: str | Path) -> ManifestDeps:
                 if not manifest.is_file():
                     continue
                 if any(
-                    part in ("node_modules", "vendor", ".venv", "venv", "target", "packages")
+                    part in ("node_modules", "vendor", ".venv", "venv", "target")
                     for part in manifest.parts
                 ):
+                    # note: "packages" is intentionally NOT excluded — it is the
+                    # standard JS workspace layout (packages/<name>/package.json).
                     continue
                 try:
                     text = manifest.read_text(encoding="utf-8", errors="replace")

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/graph/scoring.py

@@ -33,7 +33,7 @@ _LENGTH_DECAY = 0.97
 _CONST_TOKEN = re.compile(
     r"""^(
         \s | , | = | \( | \) | \[ | \] | \{ | \} | : |
-        '[^']*' | "[^"]*" | `[^`]*` |
+        '[^']*' | "[^"]*" | `(?:[^`$]|\$(?!\{))*` |   # backtick: no ${...} interpolation
         \d[\d_.eExXaAbBcCdDfF]* |
         True|False|None|null|true|false|nil |
         [A-Za-z_]\w*\s*=          # kwarg name before '='

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/pipeline/scanner.py

@@ -11,8 +11,10 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 import time
 from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures.process import BrokenProcessPool
 from datetime import UTC, datetime
 from pathlib import Path
 
@@ -147,19 +149,36 @@ def index_repository(
 def _pool_context():
     """multiprocessing context for the parse pool.
 
-    Prefer ``fork`` where available (POSIX): unlike the ``spawn`` default on
-    macOS/Windows, fork does not re-import the caller's ``__main__`` module, so
-    ``CodeGraph.index()`` works from any calling context — scripts without an
-    ``if __name__ == "__main__"`` guard, notebooks, web request handlers — rather
-    than raising a bootstrapping RuntimeError and re-running top-level code in
-    every worker. tree-sitter parsers are created lazily inside each worker, so
-    there is no pre-fork C state to corrupt.
+    On Linux, prefer ``fork``: unlike ``spawn``, fork does not re-import the
+    caller's ``__main__`` module, so ``CodeGraph.index()`` works from any calling
+    context — scripts without an ``if __name__ == "__main__"`` guard, notebooks,
+    web request handlers — rather than raising a bootstrapping RuntimeError and
+    re-running top-level code in every worker. tree-sitter parsers are created
+    lazily inside each worker, so there is no pre-fork C state to corrupt.
+
+    macOS is excluded: ``fork`` without ``exec`` is unsafe there because Apple
+    system frameworks (Objective-C runtime, libdispatch) abort the child if they
+    were touched by any thread in the parent (``+[NSNumber initialize] may have
+    been in progress ... when fork() was called``). macOS and Windows use
+    ``spawn``; the CLI entry points are ``__main__``-guarded, and unguarded
+    library callers fall back to sequential extraction in ``_parse_phase``.
     """
     import multiprocessing as mp
 
-    if "fork" in mp.get_all_start_methods():
+    if sys.platform != "darwin" and "fork" in mp.get_all_start_methods():
         return mp.get_context("fork")
-    return mp.get_context()  # spawn (Windows); callers must guard __main__
+    return mp.get_context("spawn")
+
+
+def _extract_sequential(
+    to_index: list[WalkedFile],
+) -> list[tuple[str, FileExtraction, bool]]:
+    results = []
+    for wf in to_index:
+        result = extract_one(wf)
+        if result is not None:
+            results.append(result)
+    return results
 
 
 def _parse_phase(
@@ -169,19 +188,20 @@ def _parse_phase(
         return []
     workers = max_workers if max_workers is not None else (os.cpu_count() or 2)
     if len(to_index) < _PARALLEL_THRESHOLD or workers <= 1:
-        results = []
-        for wf in to_index:
-            result = extract_one(wf)
-            if result is not None:
-                results.append(result)
-        return results
+        return _extract_sequential(to_index)
 
     batches = [to_index[i : i + _BATCH] for i in range(0, len(to_index), _BATCH)]
-    results = []
-    with ProcessPoolExecutor(max_workers=workers, mp_context=_pool_context()) as pool:
-        for batch_result in pool.map(extract_batch, batches):
-            results.extend(batch_result)
-    return results
+    try:
+        results = []
+        with ProcessPoolExecutor(max_workers=workers, mp_context=_pool_context()) as pool:
+            for batch_result in pool.map(extract_batch, batches):
+                results.extend(batch_result)
+        return results
+    except BrokenProcessPool:
+        # A worker pool couldn't start or died (e.g. an unguarded __main__ under
+        # spawn, or a sandbox with no subprocess support). Degrade to correct,
+        # single-threaded extraction rather than crashing the whole index.
+        return _extract_sequential(to_index)
 
 
 def _load_or_create_repo(session: Session, root: Path, incremental: bool) -> Repository:
@@ -285,12 +305,13 @@ def _write_files(
         for path, fid in session.execute(select(File.path, File.id).where(File.repo_id == repo.id)):
             file_id_by_path[path] = fid
 
-    reindexed = {w.path for w in diff.to_index} | {
+    to_index_paths = {w.path for w in diff.to_index}
+    reindexed = to_index_paths | {
         w.path for w in walked if w.skip_reason and w.path not in file_id_by_path
     }
     new_rows = []
     for wf in walked:
-        if wf.path in file_id_by_path and wf.path not in {w.path for w in diff.to_index}:
+        if wf.path in file_id_by_path and wf.path not in to_index_paths:
             continue  # unchanged; row already present
         if wf.path not in reindexed and not wf.skip_reason:
             continue

{entrygraph-0.1.3 → entrygraph-0.1.5}/src/entrygraph/resolve/resolver.py

@@ -71,6 +71,7 @@ class FileResolver:
         self.module_symbol_id = module_symbol_id
         self.table = table
         self.externals = externals
+        self.is_package = is_package
         self.prefix = LANG_PREFIX.get(extraction.language, extraction.language)
         self.import_map, self.wildcard_modules = build_import_map(extraction, is_package)
 
@@ -122,7 +123,9 @@ class FileResolver:
         seen: set[str] = set()
         for imp in self.x.imports:
             module = (
-                expand_relative(imp, self.x.module_path, False) if imp.is_relative else imp.module
+                expand_relative(imp, self.x.module_path, self.is_package)
+                if imp.is_relative
+                else imp.module
             )
             if not module or module in seen:
                 continue

{entrygraph-0.1.3 → entrygraph-0.1.5}/tests/test_entrypoint_expansion.py

@@ -160,6 +160,17 @@ def test_lambda_js_handler_rule():
     assert hints and hints[0].kind is EntrypointKind.LAMBDA_HANDLER
 
 
+def test_typer_command_reports_typer_not_click():
+    # typer reuses click's decorator shape; the hint must carry framework/rule_id
+    # for typer, not be mislabeled as click.
+    sym = _sym("serve", "cli.serve")
+    sym.decorators = ["@app.command()"]
+    hints = _run("python.typer.command", _extraction([sym]), frameworks=frozenset({"typer"}))
+    assert hints
+    assert hints[0].framework == "typer"
+    assert hints[0].rule_id == "python.typer.command"
+
+
 def test_sidekiq_worker_rule():
     from entrygraph.detect.entrypoints import rules_for
 

{entrygraph-0.1.3 → entrygraph-0.1.5}/tests/test_frameworks.py

@@ -33,6 +33,18 @@ def test_language_gating():
     assert not any(d.name == "rails" for d in detected)
 
 
+def test_aws_lambda_js_detected_from_serverless_config():
+    # the javascript.aws-lambda.handler entrypoint rule is gated on this spec;
+    # regression: the spec was missing, so the rule could never fire.
+    detected = detect_frameworks(
+        ManifestDeps(javascript={"@types/aws-lambda"}),
+        import_signals=set(),
+        file_paths=["serverless.yml"],
+        languages_present={"javascript"},
+    )
+    assert any(d.name == "aws-lambda-js" for d in detected)
+
+
 def test_typescript_counts_for_js_frameworks():
     manifests = ManifestDeps(javascript={"express"})
     detected = detect_frameworks(

{entrygraph-0.1.3 → entrygraph-0.1.5}/tests/test_manifests.py

@@ -78,6 +78,17 @@ def test_parse_manifests_fixture():
     assert "requirements.txt" in deps.sources
 
 
+def test_parse_manifests_reads_js_workspace_packages(tmp_path: Path):
+    # `packages/<name>/package.json` is the standard JS workspace layout and must
+    # not be excluded (regression: "packages" was in the skip list).
+    pkg = tmp_path / "packages" / "api"
+    pkg.mkdir(parents=True)
+    (pkg / "package.json").write_text('{"dependencies": {"express": "^4"}}')
+    deps = parse_manifests(tmp_path)
+    assert "express" in deps.javascript
+    assert "packages/api/package.json" in deps.sources
+
+
 # ---------------- C1: C#, PHP, Rust manifests ----------------
 from entrygraph.detect.manifests import (  # noqa: E402
     parse_cargo_toml,

entrygraph-0.1.5/tests/test_pool.py

@@ -0,0 +1,64 @@
+"""Parse-pool start method selection and graceful fallback (issue #5)."""
+
+from __future__ import annotations
+
+import multiprocessing as mp
+
+import pytest
+
+from entrygraph.fs.walker import WalkedFile
+from entrygraph.pipeline import scanner
+
+
+def _walked(n: int) -> list[WalkedFile]:
+    return [
+        WalkedFile(
+            path=f"f{i}.py",
+            abs_path=f"/repo/f{i}.py",
+            language="python",
+            size_bytes=1,
+            mtime_ns=0,
+        )
+        for i in range(n)
+    ]
+
+
+def test_pool_context_avoids_fork_on_macos(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("sys.platform", "darwin")
+    ctx = scanner._pool_context()
+    assert ctx.get_start_method() != "fork"
+
+
+def test_pool_context_uses_fork_on_linux(monkeypatch: pytest.MonkeyPatch) -> None:
+    if "fork" not in mp.get_all_start_methods():
+        pytest.skip("fork start method unavailable on this platform")
+    monkeypatch.setattr("sys.platform", "linux")
+    ctx = scanner._pool_context()
+    assert ctx.get_start_method() == "fork"
+
+
+def test_parse_phase_falls_back_when_pool_breaks(monkeypatch: pytest.MonkeyPatch) -> None:
+    to_index = _walked(scanner._PARALLEL_THRESHOLD + 5)
+
+    def fake_extract_one(wf: WalkedFile):
+        return (wf.path, object(), True)
+
+    class _BrokenPool:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+        def map(self, *args, **kwargs):
+            raise scanner.BrokenProcessPool("simulated worker death")
+
+    monkeypatch.setattr(scanner, "extract_one", fake_extract_one)
+    monkeypatch.setattr(scanner, "ProcessPoolExecutor", _BrokenPool)
+
+    results = scanner._parse_phase(to_index, max_workers=4)
+
+    assert [r[0] for r in results] == [wf.path for wf in to_index]

{entrygraph-0.1.3 → entrygraph-0.1.5}/tests/test_resolver.py

@@ -57,6 +57,38 @@ def test_import_based_project_resolution():
     assert call.confidence is Confidence.IMPORT
 
 
+def test_relative_import_from_package_init_resolves_submodule():
+    # `from .sub import thing` in the package's own __init__.py (module_path
+    # "app", is_package=True) must resolve to the project module "app.sub".
+    # Regression: is_package was hardcoded False, dropping "app" and yielding a
+    # bogus ".sub" external placeholder.
+    table = make_table()
+    table.add_module("app.sub", 20)
+    x = FileExtraction(
+        path="app/__init__.py",
+        language="python",
+        module_path="app",
+        parse_ok=True,
+        error_count=0,
+        imports=[
+            RawImport(
+                module="sub",
+                imported_name="thing",
+                alias="thing",
+                span=SPAN,
+                is_relative=True,
+                relative_level=1,
+            )
+        ],
+    )
+    externals = ExternalRegistry(iter(range(100, 200)).__next__)
+    resolver = FileResolver(x, 1, table, externals, is_package=True)
+    edges = resolver.resolve()
+    imp = next(e for e in edges if e.kind is EdgeKind.IMPORTS)
+    assert imp.dst_qname == "app.sub"
+    assert imp.dst_symbol_id == 20
+
+
 def test_external_import_creates_placeholder():
     table = make_table()
     imports = [RawImport(module="subprocess", imported_name=None, alias="sub", span=SPAN)]

{entrygraph-0.1.3 → entrygraph-0.1.5}/tests/test_scoring.py

@@ -17,6 +17,15 @@ def test_is_constant_args():
     assert not is_constant_args("(a, b, c, d, e, f, ...")
 
 
+def test_js_template_literal_interpolation_is_not_constant():
+    # a plain backtick template with no interpolation is a literal
+    assert is_constant_args("(`ls -la`)")
+    # `${...}` carries a variable into the sink -> the archetypal JS command
+    # injection must NOT be scored as constant/safe
+    assert not is_constant_args("(`ls ${req.query.dir}`)")
+    assert not is_constant_args("(`${userInput}`)")
+
+
 def test_score_path_ordering_by_severity():
     common = {
         "hop_confidences": [int(Confidence.EXACT)],